Search by Keyword
Pages
Code Quality
Timeline App
Installation Overview
Upgrade
Macros
Introduction
Managing Apps
Polyglot
Storage System
App Store App
Timeline
Feeds' Comments
  • Simon, honestly, instead of paying for multiple KVM servers and creating extra points of failure, you’d be better off with a dedicated server at Hetzner.

    Comparison:

    2x Hostinger KVM 8 – €19.99/month (renews at €49.99/month)

    • 8 vCPU
    • 32 GB RAM
    • 400 GB NVMe SSD
    • 32 TB bandwidth

    Hetzner Auction Dedicated (Budget option) – €41.29/month

    • Intel Core i7-8700
    • 2 × 1TB NVMe SSD
    • 128 GB DDR4 RAM (4 × 32 GB)
    • 1 Gbit Intel NIC unlimited bandwidth

    Hetzner Auction Dedicated (Performance / Long-term option) – ~ €103.17/month

    • Intel Core i9-9900K
    • 2 × 1TB NVMe SSD
    • 2 × 3.84TB SATA Datacenter SSDs (huge extra storage)
    • 128 GB DDR4 RAM (4 × 32 GB)
    • 1 Gbit Intel NIC unlimited bandwidth

    👉 For nearly the same price as two KVM 8s, the i7 option gives you far more RAM and storage, with no need to daisy-chain servers.

    👉 And if you want something more powerful and future-proof, the i9 option with nearly 9 TB of total SSD storage is still very reasonable at ~€103/month.

    I also recommend enabling Hetzner’s backup service then you’ll be fully covered.

    Hetzner also provides an S3-compatible storage API you can use as a CDN. You can even create internal private networks between servers to scale later.

    Honestly, I don’t see any reason to stay stuck with VPS when you’re past the beginner stage. VPS is fine for tuild cheap private cloud , or testing apps, but not for production. Spending time trying to daisy chain VPS instances for storage is, in my opinion, a mistake.

    You can read all the documentation you want, but without real power your site will stay in the same place. If you want to grow profesional website, go to dedicated servers, an then plan ahead and build a private cloud, and you’ll be in a much stronger position. If you don't like Hetzner, there are other providers.

    Without investment you can't have expectations. From my point of view, this topic is closed. Good luck

    • Absolutely amazing, What a great asset to una @Romulus

      • Also a simple setup for Permanent NFS Setup for UNA APP on Debian

        NFS Server Setup

        1. Install NFS server:
        sudo apt update sudo apt install -y nfs-kernel-server 
        
        1. Create shared storage folder:
        sudo mkdir -p /mnt/storage sudo chown -R nobody:nogroup /mnt/storage sudo chmod 775 /mnt/storage 
        
        1. Configure exports:

        Edit /etc/exports:

        /mnt/storage 10.0.0.0/24(rw,sync,no_subtree_check,all_squash,anonuid=33,anongid=33)
        
        • 10.0.0.0/24 → your private network
        • all_squash, anonuid=33, anongid=33 → maps all files to www-data (uid 33) for proper UNA APP permissions
        1. Export the folder and start NFS:
        sudo exportfs -a sudo systemctl enable nfs-server sudo systemctl restart nfs-server 
        
        1. Optional firewall:
        sudo ufw allow from 10.0.0.0/24 to any port nfs 
        

        NFS Client Setup (UNA APP Server)

        1. Install NFS client:
        sudo apt update sudo apt install -y nfs-common 
        
        1. Create mount point for UNA APP:
        sudo mkdir -p /var/www/una/storage sudo chown www-data:www-data /var/www/una/storage sudo chmod 775 /var/www/una/storage 
        
        1. Test manual mount:
        sudo mount -t nfs <NFS_SERVER_IP>:/mnt/storage /var/www/una/storage 
        

        Check:

        df -h | grep storage 
        

        Make NFS Mount Permanent

        1. Edit /etc/fstab:
        <NFS_SERVER_IP>:/mnt/storage /var/www/una/storage nfs defaults,_netdev,auto 0 0
        
        • _netdev → ensures mount waits for network
        • auto → mounts automatically on boot
        1. Test fstab:
        sudo mount -a 
        

        No errors → mount will survive reboots.

        Summary

        • NFS storage mounted permanently at /var/www/una/storage
        • Fully compatible with UNA APP
        • Permissions mapped to www-data
        • No other services included – simple, scalable, and persistent


        💡 Recommendations for NFS Setup

        1. Use a dedicated disk
        • Always allocate a separate, empty disk for NFS storage.
        • Avoid using the same disk as the operating system.
        • This prevents I/O bottlenecks and ensures better performance.
        1. Keep workloads separate
        • Do not mount NFS on the OS disk.
        • Mixing operating system and storage workloads will slow down the entire system.
        1. Configure file descriptor limits
        • NFS and applications like UNA may open thousands of files simultaneously.
        • Increase nofile limits to avoid errors such as “Too many open files”.
        1. Use a private network
        • Isolate NFS traffic from public traffic (VLAN, VPN, or dedicated NIC).
        • This prevents slowdowns for your users and improves security.
        1. Plan for scalability
        • NFS is suitable for temporary or small-scale setups.
        • For long-term growth and higher performance, migrate to OpenStack Cinder or another distributed storage backend.

        ⚠️ Note:

        NFS is a simple and functional solution for temporary storage or basic setups. However, it does not scale well with multiple volumes or high traffic. If you want a cloud-ready setup, NFS can be a starting point, but the recommended long-term approach is OpenStack with a dedicated storage backend for performance and scalability.

        👉 In short: dedicate hardware for NFS, configure limits, isolate storage traffic, and use NFS as a stepping stone toward a scalable cloud infrastructure.

        ⚠️ IMPORTANT NOTICE

        • 🚨 These commands and configuration changes are for informational purposes or development.
        • 💾 They DO NOT represent an official setup guide.
        • ⚙️ Run them ONLY if you fully understand what they do.
        • ❗ Use at your own risk. Adjust if necessary.
        • 👉 This example is intended for advanced users only.

        ✨ Happy coding!

          • @Romulus I thank you for your input I really do and knowledge is king. So thank you, We do have trouble using some services due to the nature of out business " I will let you work that out" for this reason many services will not handle our content, we are big in the area we service and growing fast, I would really prefer a method of using a second server just to use the disk space if this is possible within the archtecture of simplicity. I know its not perfection in any way, I have studied your posts in detail and this would be great of course to impliment the Amazon s3 but I have spoken with them in person and they would not handle our content. We probably have around 14 days of space left, so it is paramount to find a solution . Just to give you the picture in brief we have 2 una sites and a range of other sites including TV & Radio an other servers. I do enjoy your posts they are always full of knowledge that I appreciate your time and effort. Simon

            • How much disk space, RAM, and CPU do you need in total?

              You can set up a cloud-native infrastructure using OpenStack with Block Storage (Cinder) over NFS, deployed on dedicated servers, and scale out infinitely.

              Since most cloud providers use OpenStack, building your own private cloud is the most cost-effective solution for long-term growth. To get started, you need at least three dedicated servers, though some services can run together or on cloud VMs depending on load and redundancy. This setup is ideal for hosting the UNA APP on one or more sites. Affordable dedicated servers from providers like Hetzner can be used to build such an infrastructure.

              Minimal server setup for a functional OpenStack cluster

              1. Controller node

              • Services: Keystone, Glance, Neutron-server, Nova API, RabbitMQ, MariaDB, Cinder API
              • CPU: 8–16 cores
              • RAM: 32–64 GB
              • Disk: 500 GB+ SSD
              • Notes: Handles control plane and management services. Horizon (dashboard) and databases can optionally run on compute VMs.
              • Servers required: 1 (can scale to 2–3 for HA)

              2. Compute node

              • Services: Nova compute, optionally Cinder-volume
              • CPU: 16–32 cores
              • RAM: 64–128 GB
              • Disk: 1–2 TB SSD/NVMe
              • Notes: Runs VMs; optional services like Horizon or lightweight databases can be hosted here.
              • Servers required: 1–2 to start; more can be added to scale VM capacity

              3. Storage / NFS node

              • Services: Cinder backend, NFS
              • CPU: 8–16 cores
              • RAM: 32–64 GB
              • Disk: Depends on block storage needs (high disk count, optionally RAID)
              • Notes: Provides block storage volumes; can be combined with a compute node in small deployments, but dedicated storage servers are recommended.
              • Servers required: 1 to start; more can be added as storage demand grows

              Additional notes

              • Trove (databases) can run on a dedicated DB server, controller, or compute VM depending on size and HA requirements.
              • Minimal functional OpenStack requires at least 3 servers.
              • For redundancy or high availability, additional nodes are recommended: extra controllers, extra compute nodes, and extra storage nodes.

              OpenStack services and flexibility (open-source)

              • Compute: Nova – creates and manages VMs; requires ≥1 compute node; scales horizontally.
              • Block Storage: Cinder – creates virtual volumes attachable to instances; requires ≥1 storage server, can share with compute in small deployments.
              • Databases: Trove – DBaaS; can run on controller, dedicated DB server, or compute VM.
              • Dashboard / Management: Horizon – can run on controller or compute VM.
              • Identity / Authentication: Keystone – must run on controller.
              • Image service: Glance – runs on controller; can combine with other controller services.
              • Networking: Neutron – runs on controller; minimal agents on compute nodes.
              • Messaging & DB backend: RabbitMQ and MariaDB/MySQL – typically on controller; can be separated for performance.

              Summary

              • Minimum servers: 3 (1 controller, 1 compute, 1 storage)
              • Flexible options: Horizon, Trove, and some databases can run on compute VMs or combined nodes.
              • Scalability: Add more compute nodes for VMs, storage nodes for block storage, and controller nodes for HA.
              • Scaling strategy: Start with horizontal scaling using multiple small servers for redundancy. Once you have 10–12 servers, vertical scaling (more CPU/RAM per node) can be considered.

              Advantages of this setup

              • Cost-effective: Dedicated servers for storage and compute reduce long-term expenses.
              • Scalable: Easily add compute or storage nodes; you can create as many virtual disks, cloud servers, CDN , DB, or services as needed.
              • Flexible: Horizon, Trove, and databases like MySQL, PostgreSQL, MongoDB can run on VMs, optimizing resource usage.
              • Redundancy & High Availability: Extra nodes can be added to ensure HA.
              • Cloud-native: Fully compatible with OpenStack, portable and compatible with most cloud providers.
              • Optimized performance: Dedicated storage and compute nodes provide better I/O and CPU performance.
              • Rich ecosystem: OpenStack offers a wide array of services; the best solution for an open-source private cloud.
              • Future-proof: Start small and expand infrastructure as your UNA APP grows.

              Estimated Monthly Cost per Server

              • Controller Node: €37.30 – €42.00
              • Compute Node: €37.30 – €42.00
              • Storage / NFS Node: €37.30 – €42.00

              Notes:

              • Prices are based on Hetzner’s dedicated server offerings and may vary.
              • Setup fees, additional storage, and extra bandwidth may increase costs.
              • When scaling horizontally, each additional server will have a similar monthly cost.

              More info: https://www.openstack.org/

              If you need help, I can set up the infrastructure for you, including migration from your existing services. This can be done without downtime by running multiple versions of the UNA APP:

              • Site replication: Replicate your existing sites in the private cloud, creating three instances for each site.
              • Database replication: Set up a MySQL/MariaDB cluster for each site to replicate your existing databases and migrate them to the cloud.
              • Reverse proxies: Replicate three Nginx reverse proxies for each current Nginx session.
              • Caddy proxy: Deploy a Caddy proxy in front of all Nginx instances to ensure your sites remain online at all times.
              • Database caching: Add a Memcached or DragonflyDB cluster to cache database queries and improve performance.
              • HTTP request caching: Add a Redis instance using Valkey Fork (open-source) on Caddy to cache HTTP requests, reducing load and improving response times.
              Note: The only data you might lose is cached memory in Memcached, if used, because we will set up Redis for web requests and DragonflyDB/Memcached for database caching. Some active sessions may be lost, and users will need to log in again.

              Pricing and service details:

              • Complete setup includes: OpenStack cluster deployment, UNA APP migration, site replication, MySQL/MariaDB clusters, Nginx and Caddy proxies, Redis (Valkey Fork), and Memcached/DragonflyDB caching.
              • One-time fee: €1,500
              • Includes: Configuration, testing, and migration with minimal or no downtime.
              • Additional services: Extra sites, high-availability setups, or custom services can be quoted separately.
              • Delivery: Service can be completed in 7 business days.
              • Small private cloud: To set up three servers, you need to purchase this service three times: Coozila Small Business UNA CMS

              Service Requirements

              To be able to offer this service safely and without interruptions, you must migrate your domain name to Coozila Small Business:

              👉 https://smallbusiness.coozila.com/

              This step ensures full integration, better reliability, and seamless migration during setup.

              If you feel confident doing it yourself, I wish you the best of luck!

              • Its looking at all options that are one workable without down time or limited and 2 cost effective .

                • I am running on Hostinger vps cloud servers . I run it with TMD before for 2 years on a dedicated server we just kep mounting more disks, It ran fine but was costing around 1400 dollars a month with the growth. and I have 2 una sites on seperate servers.

                  • Well, there is already a CDN guide and a complete manual published by the UNA team:

                    1. https://unacms.com/wiki/global-settings
                    2. https://github.com/unacms/UNA/wiki/Remote-Storage

                    I recommend keeping a copy on a local cloud storage server. Mount that folder on your UNA compute cloud server as /una/storage, and then integrate your CDN solution so that files are delivered from there onward.

                    Do not rely on the local storage folder directly on the UNA application server in production this can significantly slow down the system. That setup is only practical for testing, not for a live environment.

                    For production, you should ideally run at least three separate cloud servers: one for the UNA application, one for storage, and ideally a third one dedicated to databases. For testing purposes, however, it’s fine to run everything on a single server.

                    It’s not recommended to run UNA on a single VPS or even on a single dedicated server. In fact, running separate VPS instances for each application still introduces multiple points of failure.

                    Instead, you should rely on cloud infrastructure or dedicated server clusters. A proper production system should have at least three servers in a cluster in order to minimize failure risks and ensure redundancy.

                    Any production system without redundancy is destined to fail, it’s not a question of if, but when.

                    • Guidance on Moving Media Files to CDN / External Storage @LeonidS @Andrey Yasko and the other unacms team members.

                      We are exploring options to move our media files (uploads, user content, assets) off the local VPS storage into a CDN-style or external storage solution. The goal is to reduce disk usage on our current KVM VPS instances while keeping performance and reliability high.

                      We’d appreciate guidance on the following points:

                      1. Recommended Approach:
                      • Should we consider object storage (S3-compatible services like MinIO, Backblaze, or AWS S3) integrated with UNA? (Could be a bit to late, but who knows)
                      • Is there native UNA support for external storage or CDN offloading for media files, or would this require custom development/plugins?
                      1. Integration Considerations:
                      • What is the best practice for serving media files externally while maintaining URLs, permissions, and access control?
                      • How do we handle existing media migration so that current uploads remain available without breaking existing links?
                      1. Performance / Caching:
                      • Do you recommend pairing the storage solution with a CDN for fast global access?
                      • Are there UNA configurations to automatically serve files via a CDN?
                      1. Minimal Downtime:
                      • We aim to move files with minimal disruption to the platform. Any advice on migration strategy that avoids downtime would be very helpful.

                      Our setup: multiple KVM8 VPS instances at Hostinger, with growing user uploads quickly consuming available storage.

                      We look forward to your suggestions and best practices for safely offloading media to a CDN or object storage backend.

                      Now, I know many of you will reply in conjunction with previous responses, but just to cover all angles and yes, let the response come from the architect themselves...

                      Thank you for your guidance and input..unacms team etc..

                      Posts
                      Posts' Comments
                      • Has it been discussed as far as development as to cost for ongoing maintenance and enhancements? Apps need to keep up with OS improvements and such. As someone who has been deploying apps since 2012, while the initial release is exciting, users often discover bugs that developers did not root out in beta. Is such maintenance included in the flat rate?

                        • Hi. @Romulus - sorry for the slow reply here and thanks for your question - it has been a busy time.

                          As has been promised, NEO will be released as an open source package and made available for Premium users, although this will only happen when the package is satisfactorily stable. It should be understood that NEO will offered as a stock, opinionated solution that will require customisation for many users. Publishing of native apps is a time consuming process that many users will need support to complete. I understand that you have technical skills but users without such proficiency will no doubt require support - there will be opportunities for proficient devs within the UNA community to provide those customisation and support services as well.

                          What we are offering right now as a paid service is a fully supported service supporting users to customise NEO to their requirements and publish native apps. What you get is a hands on service from the UNA to customise the NEO app to your specific requirements, connect to existing UNA instances if required and publish native apps. Given that native app development of any complexity usually costs between $80-250k - the $40k price tag offers an extremely reasonable rate.

                          UNA team (working with some enterprise clients) have spent many 1000s of hours in developing NEO, a significant investment to create a platform that can propel aspiring app publishers into a stable, supported app experience with a significant headstart in development time and saving on resources.

                          As always - we are firmly committed to supporting the UNA community on their development journies - we can't wait to make NEO a general release, but this cannot be achieved until we know the script is 100% stable as it will no doubt requires significant resources to support our community as they learn to work with it.

                          I hope that all makes sense - we will continue to update you as NEO evolves, we are planning a few more snippet updates shortly and hopefully a more detailed walk through very soon.

                          • Hi Mark,

                            The UI truly looks great, congratulations to the team for the excellent work.

                            However, this post brings a lot of confusion and I’d really appreciate some clarification.

                            We’ve been waiting for the release of the NEO application for almost two years. It was officially stated even by Andrei Iasco himself in this video that NEO would become available in 2024.

                            At the time, Andrei replied to my comment clearly:

                            "It will be open sourced soon – we have just rebuilt it to use the new App Router in NextJS part and adding some missing features for publishing (a new editor). We will always be open source."

                            But nearly two years have passed, and there’s still no public repository, no visible CID line, and no trace of NEO on GitHub.

                            It was also previously announced that NEO would be released together with UNA version 14 and Spacenook, which are both already available. To be fair, I’m not entirely certain about that but I remember one of your earlier comments mentioning a release with UNA 14.1. However, the only version currently in development on GitHub is 15.0.0-A1 and over, and there’s no sign of a 14.1 release.

                            Someone else in the community also mentioned a possible connection with UNA Spacenook 14, though I can’t confirm that either.

                            Yet NEO is still missing from the Marketplace even for Premium users. Worse, there’s no sign of it on GitHub, and no clear communication about its current status, raising concerns that it may no longer open-source.

                            In this post, you mention building custom React-based UNA apps for up to 40k. That leads to the question many of us are now asking:

                            Will NEO which was promised to the community still be released as a downloadable module for Premium users, or has it been turned into a closed, only product?

                            A clear and honest update would be highly appreciated. Many of us supported UNA with the expectation that NEO would be a part of the Premium experience. Thank you!

                            • outside is joomla, portal is completely on UNA 12.1 stable. We rely on UNA's stability, clear code, customizability and lego like module structure. We now have 15K doctors active in our portal. And our business model to meet doctors with the pharma/medical device industry works now though it took quite a long time and needed perseverance.

                              We have advanced community features, multi language site: English, Turkish and Russian including auto translation of timeline posts. Email integration, web site builder, medical search engine, chat GPT and deepseek etc. etc. things a doctor may need, all thanks to UNA.

                              • @UMIT OZAYDIN - AI could probably already do that, however, people still want people, in the midst of the AI maelstrom, we are seeking human contact and inspiration from other humans more than ever before, aren't we? Yoga is ultimately a system to guide us towards the evolution of the human spirit, sure an AI could read all the books and instruct me what steps to take, but surely you would prefer an instructor who has themselves already taken the journey? And only a human can do that.

                                AI is wonderful in making use of information that is already there - to support us humans in making sense and refining structure of information, tools and ideas that humans have already created. From that perspective AI is perfectly applied to UNA, a system that has been developed by humans, but is too complicated for most humans to effectively utilise!

                                I know that you know what I'm saying here, I think our jobs are safe for a little while yet!

                                • Hey @UMIT OZAYDIN - yes it is, no doubt, AI is out there breaking down barriers, revolutionising industries and blowing minds, however as you have no doubt understood from the translation industry, there is a long way to go! AI is amazing at the basic rote stuff, but when it comes to understanding nuance and complex strategy, it still helps to have a few humans in your corner!

                                  • Hello @Alexey Mir !

                                    For now it's better to use our documentation:

                                    https://unacms.com/wiki/Introduction

                                    • @LeonidS @PavelS do you know smth about the videos above? How to find it?

                                      • this video is private, any way to see it? @Mark Purser @LeonidS

                                        • Yay, so happy that you're working on documentation! As I've been learning UNA I've been thinking that this app would be so much more accessible (and get more users!) with better documentation. I have had to simply install it, and keep turning things off and on again, and make a bunch of test profiles and test posts all over the place just to figure out what all the settings do!

                                          Right now I have a deadline by which I need to complete all the basic areas of our UNA site (April 13-14), but when that is complete (and after I take a couple week break lol), if you are interested, I would love to contribute by helping with writing documentation and tutorials. I have a "Guide to UNA" written already that's designed to explain basic concepts to a brand new user with zero technology experience. It's very tailored to our community - and it talks about differences between UNA and Wordpress since we migrated from Wordpress to UNA - but would be easy to adapt!

                                          I can't post links but here's a preview:

                                          image_transcoder.php?o=sys_images_editor&h=1854&dpx=1&t=1710936905I have just gotten our community site to the point where it's ready for people to join, with customized membership levels, and profiles and discussions are fully operational, and I'm really impressed with how tiny the list of CSS code I had to write is so far!

                                          Albums
                                          •  · 
                                          •  ·  grlinux
                                          These are some photos from my members Roller Coaster Tycoon park builds. Each build is block of graphics.
                                          Albums' Comments
                                          • No clue what you're saying... the horror, diarrhea of the mouth at best.
                                            Most of your educational, useful and resourceful videos are still inaccessible for the deaf customers like me. I did request video "Subtitle" feature six years ago in Dolphin (https://www.boonex.com/n/html5-video)... it has largely been ignored and still today with UNA.
                                            Hulu, Netflix, VLC, Youtube... to name a few, already implement long time ago and we still lack?
                                            Patiently waited for six years... how much longer? Hearing privilege is as bad as White privilege. Please stop, start caring and sharing. For our sites, we demand such a feature because it's mandatory and it's right thing to do... for the sake of people who are deaf-blind like Helen Keller.
                                            C'arn Andrew, I'm pushing you for UNA and Dolphin to be the first to offer 21st Century Communications and Video Accessibility before someone else does!
                                            Images
                                            • 1779
                                            • More
                                            • 1837
                                            • More
                                            • 1660
                                            • More
                                            • 1711
                                            • More
                                            OnlinedotMeupdate2.mp4
                                            06:35
                                            • 3805
                                            • 1
                                            • More
                                            61F4F463-2FBE-4BB8-B6D7-51E17E12C4D2.MOV
                                            00:06
                                            • 1
                                            • More
                                            • 1789
                                            • 1
                                            • More
                                            • 1706
                                            • More
                                            • 1762
                                            • More
                                            Images Comments
                                            • In the very early days of the Apple Store I remember hearing Steve Jobs saying that Native Apps were just a stage we were moving through, and that in 10 years time (ie 2018) the only platform worth coding for would be the WWW. Obviously native apps are alive and well, but with the rapid evolution of Progressive Web Apps, one must wonder for how long this will be the case.

                                              Whatever the case with the potential future of Native Apps, taking the time to grow the community and evolve the platform within the far more flexible platform of progressive web apps is the smart move.

                                               

                                              Articles
                                              Files
                                              Polls
                                              •  · 
                                              •  ·  Scholar
                                              •  · 
                                              •  ·  Alchemy
                                              Polls' Comments
                                              Products by category: Development
                                              Products' Reviews
                                              • I purchased the subscription for Plyr today. I am pleased with the video player upgrade. It has all the features I need. It looks clean and operates smoothly. I am sure my site users will enjoy using it. I am attaching a screenshot of what it looks like.

                                                image_transcoder.php?o=sys_images_editor&h=2747&dpx=1&t=1751078897

                                                • This module is not working for whatever reason. @Jerome Mingo is there anyway to fix this?

                                                  • Thank you for contributing to the improvement of our modules!

                                                    Regarding updates, our modules do not contain any instructions that recreate the language file from the default version or delete existing keys. During an update, only the instructions found in the install/lang/ folder of the update patch are executed. These instructions may add, update, or remove certain keys.

                                                    All your custom changes that are already stored in the database will remain intact - unless they are explicitly meant to be changed by the update itself. You can review all language keys affected by the update in the files located in the install/lang/ folder of the patch.

                                                    Also, if you have created your own language file for a custom language, it will not be affected at all, since it doesn’t exist in the default package. So, there's no need to worry about losing any of your changes when updating the module through the admin panel.

                                                    As for the versions: the previous version was 12.0.7, not 12.0.5. So you should first update to 12.0.7, and then proceed to 13.0.0. I believe you can do all updates directly through the Studio, without needing to do it manually.

                                                    • @AQB Soft

                                                      Thanks for the release of the Affiliate Program version 13.0.0. Thanks for all the efforts you have been doing to improve the module. I have compared its language file with the one from the previous version (12.0.5) and I noticed that there are some key changes and new lang keys were introduced.

                                                      So, how can I update my Affiliate Program translations too? I have the Affiliate module translated in two languages.

                                                      Updating the Affiliate Program straight from studio will not update translations. Should I manually download the Affiliate module from the UNA Marketplace, then upload it to the server via FTP with with my updated language files?

                                                      Please could you guide me with a comprehensive way to smoothly update my Affiliate Program translations too without losing the translations (modifications in some language keys) I have made previously?

                                                      Thanks

                                                      • Using PHP 8.2 the /www/periodic/cron.php dies when this module is enabled. It returns this error.

                                                        PHP Deprecated:  Creation of dynamic property AqbMtcConfig::$_bLiteMode is deprecated in /public_html/modules/aqb/mainten
                                                        ance/classes/AqbMtcConfig.php on line 43
                                                        
                                                        • There is no such option unfortunately. Due to a 2 reasons I've mentioned above:

                                                          1) The albums module in UNA does not provide a custom sized thumbnails for photos. Instead it provides a fixed size/aspect ratio thumbnails to be used in galleries and previews. The Photos Carousel module does not create its own photos, it just uses what the source module offers.

                                                          2) All items in the Photos Carousel must be of the same size for the transitions and animations to work correctly.

                                                          • Nobody is misleading you. Our screenshot has been taken when the Photos Carousel is using the Photos module as a source. All thumbnails in the photos module are of 300x200 size. And yes, they still get cropped in case a photo doesn't meet the 3/2 aspect ratio. In your case you seem to be using the Albums module as a source - in that module all thumbnails are square.

                                                            • Then your marketing is misleading because it shows photos with a proper aspect ratio and not square like mine.

                                                              Mine: Portrait Pics cut off...image_transcoder.php?o=sys_images_editor&h=2695&dpx=2&t=1747158456

                                                              Yours:image_transcoder.php?o=sys_images_editor&h=2694&dpx=2&t=1747158269

                                                              • @Jerome Mingo I am having this same issue and there is no way to edit it. Also, is there a way to allow the profile user to inject code? Similar to a facebook pixel, or an embed?

                                                                • I installed this on my 14.0.0-RC2 installation. It works well and loads fast. The header image placement looks good. The animated poll results are nice. You can add polls through your profile or in groups. I would definitely recommend this module.

                                                                  Groups
                                                                  Organizations
                                                                  Persons
                                                                  Channels
                                                                  Tasks
                                                                  Tasks' Comments
                                                                  • What we have today (quick audit)

                                                                    • Two auth modes: API Key (Studio-generated) calling api.php with r=<module/method/class>&params=...; and OAuth2 with public (/m/oauth2/token) + private endpoints (/m/oauth2/api/me|user|friends|market|service). Responses are JSON; most calls are GET (even where not ideal). 
                                                                    • Service gateway: “unsafe service” flag lets clients remotely invoke module service functions (e.g., bx_posts/entity_add) by name; the canonical list of service methods lives in auto-generated docs. 

                                                                    What we’re aiming for

                                                                    • Contract-first REST API with OpenAPI 3.1 (latest) using JSON Schema 2020-12; proper HTTP methods, resource-oriented URLs, strong typing, and first-class docs/SDKs. 
                                                                    • Consistent auth, error model, pagination, filtering, and webhooks; no remote-procedure “service” calls exposed to the public surface.

                                                                    Migration strategy (three phases)

                                                                    Phase 0 — Document & contain legacy (1–2 sprints)

                                                                    1. Publish an OAS file for the existing surface (legacy):
                                                                    • POST /m/oauth2/token (OAuth2), GET /m/oauth2/api/*, GET /api.php with r + params. Mark as deprecated: true and scope-lock (e.g., only server-side). 
                                                                    1. Gateway hardening: default Allow access to unsafe services = off; audit which service methods truly need exposure; everything else internal-only. 
                                                                    2. Introduce unified error shape = RFC 7807/9457 application/problem+json. (Keep legacy payloads for gateway, but wrap at edge if feasible.) 
                                                                    3. Stand up docs portal (Redoc/Swagger-UI) from the OAS; run a linter (Spectral) in CI.

                                                                    Phase 1 — New “v1” REST surface (parallel to legacy)

                                                                    Design & ship resource-based endpoints for the core domain (Accounts, Profiles, Posts, Comments, Files, Reactions, Connections, Notifications, Timeline). Each maps to well-known UNA modules under the hood (temporarily via an adapter that calls the corresponding service function).

                                                                    Example mappings (conceptual):

                                                                    Legacy service call

                                                                    Proposed REST

                                                                    bx_posts/entity_add via api.php

                                                                    POST /v1/posts

                                                                    bx_posts/entity_update

                                                                    PATCH /v1/posts/{id}

                                                                    bx_posts/entity_delete

                                                                    DELETE /v1/posts/{id}

                                                                    BxBaseVoteServices::serviceDo

                                                                    POST /v1/posts/{id}/reactions

                                                                    BxTimelineModule::serviceGetPosts

                                                                    GET /v1/timeline?ownerId=…

                                                                    (Use the service list to complete the map for each module.) 

                                                                    Phase 2 — Deprecate gateway, keep OAuth2

                                                                    • Freeze gateway features; publish dates for removal; point developers to REST. Keep OAuth2 (authorization_code, client_credentials) as primary security scheme. 

                                                                    Design rules & patterns (apply to all new endpoints)

                                                                    1) Versioning & paths

                                                                    • Prefix: /v1/{resource}; nouns, plural.
                                                                    • Resource IDs: string (stable, non-guessable).
                                                                    • Relationships: nested collections where natural, e.g., /posts/{id}/comments.

                                                                    2) Methods & semantics

                                                                    GET (list/read), POST (create + non-idempotent actions), PATCH (partial update, JSON Merge Patch), DELETE (idempotent delete).

                                                                    • Use 201 with Location on create; 204 on delete/update with no body; 409 for conflicts; 422 for validation errors (with RFC 7807 payload).

                                                                    3) Authentication & authorization

                                                                    • OAuth2 as primary: authorizationCode, clientCredentials (scopes: read:posts, write:posts, etc.).
                                                                    • API keys only for server-to-server (header X-API-Key), not for end-user flows.
                                                                    • Model both in OpenAPI components.securitySchemes. 

                                                                    4) Errors (mandatory)

                                                                    • Return application/problem+json with fields: type, title, status, detail, instance, plus errors (field-level). Define schema & examples in OAS. 

                                                                    5) Pagination, filtering, sorting

                                                                    • Cursor pagination for feeds: ?limit=50&cursor=eyJpZCI6… returning { data, meta: { nextCursor }, links }.
                                                                    • Offset pagination allowed for admin/grids.
                                                                    • Filtering: predictable params (e.g., ownerId, createdBefore, q), no free-form SQL fragments.
                                                                    • Sorting: sort=-createdAt,name.

                                                                    6) Sparse fieldsets & expansion

                                                                    • fields[posts]=id,title,createdAt to trim payloads;
                                                                    • expand=author,stats to embed related aggregates.

                                                                    7) Idempotency & concurrency

                                                                    • Accept Idempotency-Key on POST/PATCH of mutating endpoints;
                                                                    • Use ETag + If-Match for safe concurrent updates.

                                                                    8) Rate limiting & caching

                                                                    • Send RateLimit-Limit, RateLimit-Remaining, Retry-After.
                                                                    • ETag/Last-Modified on GET; cacheable where safe.

                                                                    9) Webhooks (OAS 3.1 )

                                                                    • Events like post.created, comment.created, reaction.added, connection.added.
                                                                    • HMAC signature header; retry with backoff; document payloads in OAS. 

                                                                    10) Internationalization & time

                                                                    • All timestamps UTC ISO-8601; server supplies locale-agnostic strings; clients format UX.

                                                                    Module-by-module blueprint (core set)

                                                                    Below are concise schemas + endpoints you can replicate per module. Each schema should align with your existing DB/UNA module fields; extend conservatively.

                                                                    Accounts & Profiles

                                                                    • GET /v1/me (current profile; OAuth2 token subject) ← replaces /m/oauth2/api/me. 
                                                                    • GET /v1/profiles/{id}; GET /v1/profiles?username=&email=; PATCH /v1/profiles/{id} (privileged).
                                                                    • Schema: Profile (id, type, name, displayName, link, picture, role, createdAt).

                                                                    Posts (bx_posts)

                                                                    • GET /v1/posts, POST /v1/posts, GET /v1/posts/{id}, PATCH /v1/posts/{id}, DELETE /v1/posts/{id}.
                                                                    • Actions: POST /v1/posts/{id}:repost, POST /v1/posts/{id}:pin, etc. Map to service functions internally. 

                                                                    Comments (cmts)

                                                                    • GET /v1/comments?objectId=&system=, POST /v1/comments, DELETE /v1/comments/{id}.
                                                                    • Tie into BxDolCmts::serviceGetAll, etc. for adapter phase. 

                                                                    Reactions / Votes / Scores

                                                                    • POST /v1/{resource}/{id}/reactions (body: { kind: "like"|"upvote" }), DELETE to remove. Map to serviceDo / serviceGetPerformedBy. 

                                                                    Connections (friends/follow)

                                                                    • GET /v1/profiles/{id}/connections, POST /v1/profiles/{id}/connections, DELETE …/{otherId}. Map from serviceGetUnconfirmedConnectionsNum, etc. (adapter). 

                                                                    Timeline / Feed

                                                                    • GET /v1/timeline?ownerId=&after=&limit=; returns heterogeneous TimelineItem[] with type, object, createdAt. Backed by BxTimelineModule services. 

                                                                    Files / Media

                                                                    • POST /v1/files (multipart or TUS), GET /v1/files/{id}, DELETE …. Wrap current storage/uploaders.

                                                                    OpenAPI 3.1 starter (drop-in example)

                                                                    openapi: 3.1.0
                                                                    info:
                                                                      title: UNA Public API
                                                                      version: 1.0.0
                                                                    servers:
                                                                      - url: https://api.example.com
                                                                    security:
                                                                      - oauth2: [read:posts]
                                                                      - apiKey: []
                                                                    paths:
                                                                      /v1/posts:
                                                                        get:
                                                                          operationId: listPosts
                                                                          summary: List posts
                                                                          parameters:
                                                                            - in: query
                                                                              name: ownerId
                                                                              schema: { type: string }
                                                                            - in: query
                                                                              name: limit
                                                                              schema: { type: integer, minimum: 1, maximum: 100, default: 20 }
                                                                            - in: query
                                                                              name: cursor
                                                                              schema: { type: string }
                                                                          responses:
                                                                            "200":
                                                                              description: OK
                                                                              content:
                                                                                application/json:
                                                                                  schema:
                                                                                    $ref: '#/components/schemas/PaginatedPosts'
                                                                            "401": { $ref: '#/components/responses/Unauthorized' }
                                                                        post:
                                                                          operationId: createPost
                                                                          summary: Create a post
                                                                          security: [{ oauth2: [write:posts] }]
                                                                          requestBody:
                                                                            required: true
                                                                            content:
                                                                              application/json:
                                                                                schema: { $ref: '#/components/schemas/PostCreate' }
                                                                          responses:
                                                                            "201":
                                                                              description: Created
                                                                              headers:
                                                                                Location: { description: Resource URL, schema: { type: string, format: uri } }
                                                                              content:
                                                                                application/json:
                                                                                  schema: { $ref: '#/components/schemas/Post' }
                                                                            "400": { $ref: '#/components/responses/ValidationError' }
                                                                      /v1/posts/{id}:
                                                                        get:
                                                                          operationId: getPost
                                                                          parameters: [{ in: path, name: id, required: true, schema: { type: string } }]
                                                                          responses:
                                                                            "200": { description: OK, content: { application/json: { schema: { $ref: '#/components/schemas/Post' } } } }
                                                                            "404": { $ref: '#/components/responses/NotFound' }
                                                                        patch:
                                                                          operationId: updatePost
                                                                          parameters: [{ in: path, name: id, required: true, schema: { type: string } }]
                                                                          requestBody:
                                                                            required: true
                                                                            content:
                                                                              application/json:
                                                                                schema: { $ref: '#/components/schemas/PostUpdate' }
                                                                          responses:
                                                                            "200": { description: OK, content: { application/json: { schema: { $ref: '#/components/schemas/Post' } } } }
                                                                            "409": { $ref: '#/components/responses/Conflict' }
                                                                        delete:
                                                                          operationId: deletePost
                                                                          parameters: [{ in: path, name: id, required: true, schema: { type: string } }]
                                                                          responses:
                                                                            "204": { description: Deleted }
                                                                    components:
                                                                      securitySchemes:
                                                                        oauth2:
                                                                          type: oauth2
                                                                          flows:
                                                                            authorizationCode:
                                                                              authorizationUrl: https://example.com/m/oauth2/authorize
                                                                              tokenUrl: https://example.com/m/oauth2/token
                                                                              scopes:
                                                                                read:posts: Read posts
                                                                                write:posts: Create or modify posts
                                                                        apiKey:
                                                                          type: apiKey
                                                                          in: header
                                                                          name: X-API-Key
                                                                      schemas:
                                                                        Post:
                                                                          type: object
                                                                          properties:
                                                                            id: { type: string }
                                                                            title: { type: string }
                                                                            text:  { type: string }
                                                                            authorId: { type: string }
                                                                            createdAt: { type: string, format: date-time }
                                                                          required: [id, title, authorId, createdAt]
                                                                        PostCreate:
                                                                          type: object
                                                                          properties:
                                                                            title: { type: string, minLength: 1 }
                                                                            text:  { type: string }
                                                                            visibility: { type: string, enum: [public, members, connections] }
                                                                          required: [title]
                                                                        PostUpdate:
                                                                          type: object
                                                                          properties:
                                                                            title: { type: string }
                                                                            text:  { type: string }
                                                                        PaginatedPosts:
                                                                          type: object
                                                                          properties:
                                                                            data: { type: array, items: { $ref: '#/components/schemas/Post' } }
                                                                            meta:
                                                                              type: object
                                                                              properties:
                                                                                nextCursor: { type: string, nullable: true }
                                                                      responses:
                                                                        Unauthorized:
                                                                          description: Unauthorized
                                                                          content:
                                                                            application/problem+json:
                                                                              schema:
                                                                                $ref: '#/components/schemas/Problem'
                                                                        NotFound:
                                                                          description: Not found
                                                                          content:
                                                                            application/problem+json:
                                                                              schema: { $ref: '#/components/schemas/Problem' }
                                                                        Conflict:
                                                                          description: Conflict
                                                                          content:
                                                                            application/problem+json:
                                                                              schema: { $ref: '#/components/schemas/Problem' }
                                                                        ValidationError:
                                                                          description: Validation failed
                                                                          content:
                                                                            application/problem+json:
                                                                              schema:
                                                                                allOf:
                                                                                  - $ref: '#/components/schemas/Problem'
                                                                                  - type: object
                                                                                    properties:
                                                                                      errors: { type: object, additionalProperties: { type: array, items: { type: string } } }
                                                                      schemas:
                                                                        Problem:
                                                                          type: object
                                                                          properties:
                                                                            type: { type: string, format: uri }
                                                                            title: { type: string }
                                                                            status: { type: integer }
                                                                            detail: { type: string }
                                                                            instance: { type: string, format: uri }
                                                                    


                                                                    Implementation pattern in UNA (PHP)

                                                                    • Contract-first: author OAS → generate PHP stubs (e.g., openapi-generator php-slim/php-mezzio) or wire into UNA’s router. Keep PSR-7/PSR-15 (nyholm/psr7 or laminas/laminas-diactoros).
                                                                    • Adapter layer (temporary): Controllers translate REST calls to current service methods, e.g.:
                                                                    • POST /v1/posts → call bx_posts/entity_add (service) with a sanitized map; return 201 + new Post. 
                                                                    • Validation: derive validators from JSON Schema in the OAS (league/openapi-psr7-validator).
                                                                    • Errors: central exception middleware → RFC 7807 payloads. 
                                                                    • Docs: serve static OAS (/openapi.yaml) and Swagger-UI/Redoc.

                                                                    Contributor/extensibility model (for apps/modules)

                                                                    • Each UNA module ships an OAS fragment (openapi/paths/*.yaml, openapi/schemas/*.yaml) + a route registrar.
                                                                    • Build step merges fragments (Redocly CLI or swagger-cli bundle) → one spec.
                                                                    • Require modules to follow the global style (naming, pagination, errors, auth scopes).
                                                                    • Provide a module template with working Postman collection & tests.

                                                                    Deeper compatibility notes

                                                                    • OAuth2 scopes: translate UNA’s existing basic|market|service into fine-grained REST scopes (e.g., read:profiles, write:profiles, market:*). Keep token endpoint as is. 
                                                                    • CORS: preserve current allow-list behavior (DB table bx_oauth_allowed_origins) for REST origins too. 
                                                                    • Autogenerated services: use ci.una.io list as ground truth while building adapters; many names already map 1:1 to CRUD or small action endpoints. 

                                                                    Acceptance checklist (ship gate)

                                                                    • OAS 3.1 validates (no errors), Spectral passes (style ruleset).
                                                                    • OAuth2 security schemes documented; working auth flows in Swagger-UI. 
                                                                    • Error payloads conform to RFC 7807; negative cases covered in tests. 
                                                                    • Pagination, filtering, sorting consistent across all list endpoints.
                                                                    • Webhooks documented under webhooks: and signature verified. 
                                                                    • Legacy gateway documented as deprecated; feature freeze enforced.
                                                                    Videos' Comments
                                                                    • I have been waiting for such an improvement for years and had almost lost hope. This option is fantastic (HTMX)! I love it—thank you so much! It works like a charm in Chrome and Opera. However, while the HTMX option shows promise, it is not yet fully usable as it doesn’t work in all browsers. Mozilla Firefox (133.0.3 64-bit) reports htmx:target and htmx:historyCacheError instead. This feedback is based on a standard installation with version 14.0.0 RC2, not for SpaceNook.

                                                                      • Navigation in https://spacenook.app/ is very disturbing, with each click the logo reloads again. It looks like a website from 20 years ago, I can't stop smiling, what do you want to brag about? Maybe this application wants to be a time machine... To be honest, I expected more from this release.

                                                                        I wouldn't have the courage to make a website in production with something like that, and I don't see the point in installing it. Thank you for the demo. I will probably check the next version.

                                                                        • Spacenook registration

                                                                          image_transcoder.php?o=sys_images_editor&h=1506&dpx=1&t=1692650409

                                                                          No confirmation email received, even when requested multiple times. How can I fix this

                                                                          Discussions
                                                                          Forum's Comments
                                                                          • Save as a file if you need further help to restore UNA permissions set_permissions.sh

                                                                            #!/bin/bash
                                                                            # Filename: set_permissions.sh
                                                                            
                                                                            # Move into the 'una' directory
                                                                            cd una || { echo "Directory 'una' not found!"; exit 1; }
                                                                            
                                                                            # Change the owner of all files and folders to 'www-data'
                                                                            sudo chown -R www-data:www-data .
                                                                            
                                                                            # Set permissions for all directories to 755:
                                                                            # 7 = read (4) + write (2) + execute (1) for the owner
                                                                            # 5 = read (4) + execute (1) for the group
                                                                            # 5 = read (4) + execute (1) for others
                                                                            sudo find ./ -type d -exec chmod 755 {} \;
                                                                            
                                                                            # Set permissions for all files to 644:
                                                                            # 6 = read (4) + write (2) for the owner
                                                                            # 4 = read (4) for the group
                                                                            # 4 = read (4) for others
                                                                            sudo find ./ -type f -exec chmod 644 {} \;
                                                                            
                                                                            # Give execute permission to ffmpeg.exe (since it's an executable)
                                                                            sudo chmod +x ./plugins/ffmpeg/ffmpeg.exe
                                                                            
                                                                            # Go back to the previous directory
                                                                            cd ..
                                                                            
                                                                            # Set this script's owner to 'root' and permissions to 755
                                                                            # If you want, replace 'root' below with your SSH username
                                                                            sudo chown root:root set_permissions.sh
                                                                            sudo chmod +x set_permissions.sh
                                                                            
                                                                            # Display confirmation message
                                                                            echo "Permissions successfully set. Script permissions preserved."
                                                                            

                                                                            How to use:

                                                                            1. Create the file:
                                                                            vim set_permissions.sh
                                                                            
                                                                            1. Press i to enter Insert mode.
                                                                            2. Paste the code from above.
                                                                            3. Save and close:
                                                                            • Press ESC
                                                                            • Type :wq
                                                                            • Press Enter

                                                                            Final steps:

                                                                            • Make the script executable:
                                                                            sudo chmod +x set_permissions.sh
                                                                            
                                                                            • Run it anytime to restore your file and folder permissions:
                                                                            ./set_permissions.sh
                                                                            

                                                                            ✅ What this script does:

                                                                            • Sets the correct ownership (www-data:www-data) and permissions for your una/ project.
                                                                            • Makes sure ffmpeg.exe stays executable.
                                                                            • Preserves its own permissions as root:root with 755, so it’s always ready to use safely.

                                                                            📁 Directory Structure

                                                                            your_project/
                                                                            ├── set_permissions.sh   ← This script is here
                                                                            └── una/                 ← The UNA CMS directory
                                                                            

                                                                            Happy coding! 🚀

                                                                            • f you need to set the correct permissions for UNA CMS, run this command:

                                                                              #!/bin/bash
                                                                              # Move into the 'una' directory
                                                                              cd una
                                                                              
                                                                              # Change the owner of all files and folders to 'www-data' (the default web server user)
                                                                              sudo chown -R www-data:www-data .
                                                                              
                                                                              # Set permissions for all directories to 755:
                                                                              # 7 = read (4) + write (2) + execute (1) for the owner
                                                                              # 5 = read (4) + execute (1) for the group
                                                                              # 5 = read (4) + execute (1) for others
                                                                              sudo find ./ -type d -exec chmod 755 {} \;
                                                                              
                                                                              # Set permissions for all files to 644:
                                                                              # 6 = read (4) + write (2) for the owner
                                                                              # 4 = read (4) for the group
                                                                              # 4 = read (4) for others
                                                                              sudo find ./ -type f -exec chmod 644 {} \;
                                                                              
                                                                              # Give execute permission to ffmpeg.exe (because it’s an executable file)
                                                                              sudo chmod +x ./plugins/ffmpeg/ffmpeg.exe
                                                                              
                                                                              # Show confirmation message
                                                                              echo "Permissions successfully set."
                                                                              

                                                                              If that doesn’t work, try this more permissive version:

                                                                              #!/bin/bash
                                                                              # Move into the 'una' directory
                                                                              cd una
                                                                              
                                                                              # Change the owner of all files and folders to 'www-data'
                                                                              sudo chown -R www-data:www-data .
                                                                              
                                                                              # Set permissions for all directories to 775:
                                                                              # 7 = read (4) + write (2) + execute (1) for the owner
                                                                              # 7 = read (4) + write (2) + execute (1) for the group
                                                                              # 5 = read (4) + execute (1) for others
                                                                              sudo find . -type d -exec chmod 775 {} \;
                                                                              
                                                                              # Set permissions for all files to 644:
                                                                              # 6 = read (4) + write (2) for the owner
                                                                              # 4 = read (4) for the group
                                                                              # 4 = read (4) for others
                                                                              sudo find . -type f -exec chmod 644 {} \;
                                                                              
                                                                              # Give execute permission to ffmpeg.exe
                                                                              sudo chmod +x ./plugins/ffmpeg/ffmpeg.exe
                                                                              
                                                                              # Show confirmation message
                                                                              echo "Permissions successfully set."
                                                                              

                                                                              Explanation of the permission numbers:

                                                                              In Linux, file permissions are represented by a three-digit number:

                                                                              • The first digit is for the owner
                                                                              • The second digit is for the group
                                                                              • The third digit is for others (everyone else)

                                                                              Each digit is a combination of:

                                                                              • 4 = read permission
                                                                              • 2 = write permission
                                                                              • 1 = execute permission

                                                                              You add them together to get the desired permissions.

                                                                              Examples:

                                                                              • 7 = 4 (read) + 2 (write) + 1 (execute) = read, write, execute
                                                                              • 6 = 4 (read) + 2 (write) = read, write
                                                                              • 5 = 4 (read) + 1 (execute) = read, execute
                                                                              • 4 = read only

                                                                              Permissions we’re using:

                                                                              • 755 for directories:
                                                                              • Owner can read/write/execute
                                                                              • Group can read/execute
                                                                              • Others can read/execute
                                                                              • Why? So the web server can access directories, and users can navigate them, but only the owner can write to them.
                                                                              • 775 for directories (alternative if group write is needed):
                                                                              • Owner and group can read/write/execute
                                                                              • Others can read/execute
                                                                              • This is slightly more open for collaborative setups.
                                                                              • 644 for files:
                                                                              • Owner can read/write
                                                                              • Group and others can only read
                                                                              • Prevents unauthorized users from modifying files while allowing the web server to read them.
                                                                              • +x for executables like ffmpeg.exe:
                                                                              • Makes the file executable for the owner, group, and others
                                                                              • Required for scripts or binaries that need to run.

                                                                              ⚠️ Why not use 777?

                                                                              • 777 = read/write/execute for everyone (owner, group, others)
                                                                              • It’s insecure because anyone can modify or delete your files.
                                                                              • Okay for local testing, but a terrible idea for live public servers.

                                                                              Have fun!

                                                                                  • Have you checked github ? Check the link - github dot com /unacms/UNA/releases/tag/15.0.0-A1 (I cant pastte link, so change dot to .). under the assets .

                                                                                    github dot com/unacms/UNA/releases/download/15.0.0-A1/UNA-Spacenook-v dot 15 dot 0 dot 0-A1 dot zip

                                                                                    ooff... I cant even paste a zip file name here.. It doesnt allow it ..

                                                                                    So there is a spacenook release for this alpha release... whatever that means.

                                                                                    image_transcoder.php?o=sys_images_editor&h=2863&dpx=2&t=1760122561

                                                                                    • Thanks @LeonidS . Is there a way that can be added by customization?

                                                                                      • The settings are changed and the audit function now shows now error (it was flawless working before also, just the checks failed)

                                                                                        The Key-Secret-Pair are checked and identical. A guess might be this:

                                                                                        When adding an installation the key gets associated to a license, but when an installation at https://unacms.com/kands-manage is deleted it gets not disassociated from the license. And then this happens:

                                                                                        Installations (https://unacms.com/kands-manage)

                                                                                        image_transcoder.php?o=sys_images_editor&h=2855&dpx=1&t=1759896527

                                                                                        and (https://unacms.com/products-licenses)

                                                                                        image_transcoder.php?o=sys_images_editor&h=2856&dpx=1&t=1759896558

                                                                                        As you can see one license is connected correctly. The other two Domain/Key-Value-Pairs do not relate.

                                                                                        Is it possible to make this connection? In the License table I can see only a button with a rubber symbol and I don't want to remove the license.

                                                                                        • In your case, the blocks on left side - "First Steps" and "Navigating the network" : are they manually created menus ? Or did una automatically create those blocks for you ?

                                                                                          I am getting a sidebar as shown below. But there are only two Main items - "Contents" and "Administration".

                                                                                          image_transcoder.php?o=sys_images_editor&h=2853&dpx=2&t=1759853867

                                                                                          Also, if you look at Unacms dot com /wiki/accounts-profiles etc (please change the url as I cannot place url here) , the left sidebar has collapsible items like "Configuration" , "Apps" , "Code" etc. They don't link to any wiki page.

                                                                                          image_transcoder.php?o=sys_images_editor&h=2854&dpx=2&t=1759854227

                                                                                          I was wondering if this was created manually or there is some special way to create it...

                                                                                          • Hello @Pepper !

                                                                                            The server settings of the third site may be have differences, you need to check the Studio->Dashboard->Server audit area. Also you may bound your license for this site to the wrong key-secret pair. You could visit the https://unacms.com/kands-manage and https://unacms.com/products-licenses pages to re-check them again.

                                                                                            • Hi @Ivy_SpEd @highlightings I think the Wiki works very well. I'm using version 13.0.1. I think you missed something in the instructions or when creating it, just like I did when I started.image_transcoder.php?o=sys_images_editor&h=2852&dpx=1&t=1759780276