Infinito.Nexus 12.0 is one of the most significant releases in the project’s history.

Until now, Infinito.Nexus focused primarily on automating complete open-source environments on a single Docker Compose host. Version 12.0 introduces Docker Swarm as a second deployment mode, enabling applications to run across multiple servers, scale horizontally and recover from node failures.

This release combines capabilities that are rarely delivered by one automation platform:

• More than 75 automatically deployable open-source applications
• One Single Sign-On experience backed by a unified user database
• Horizontal scaling across multiple cloud servers
• Automated backup and continuously tested disaster recovery
• Support across Debian, Arch Linux and RHEL-family distributions
• Filesystem-independent operation across ext4, btrfs and ZFS

Together, these changes transform Infinito.Nexus from an application installer into a comprehensive foundation for scalable, sovereign cloud infrastructure.

Scale Beyond a Single Server

The defining feature of Infinito.Nexus 12.0 is its new Docker Swarm deployment mode.

A single server remains an excellent choice for smaller organizations, private installations, development environments and cost-efficient deployments. As demand grows, however, applications must be able to use the capacity of several machines.

Version 12.0 makes that transition possible.

Infinito.Nexus can now initialize a Docker Swarm, assign manager and worker responsibilities, distribute workloads across participating nodes and connect them through shared networking and storage. Services can be replicated, restarted on another node after a failure and placed according to their operational requirements.

The new architecture includes:

• Automated Swarm initialization and node management
• Multi-manager support for a resilient Raft quorum
• NFS-backed storage shared between cluster nodes
• A private registry for distributing locally built images
• A pull-through registry cache that reduces external downloads
• Deployment-aware networking, health checks and service discovery
• Automated workload placement and replica configuration
• Cross-mode validation between Docker Compose and Docker Swarm

This is not merely a generated stack file. The complete deployment chain—from inventory resolution and dependency provisioning to health checks and end-to-end testing—understands the differences between a single-host Compose installation and a distributed Swarm environment.

For customers, this creates a practical growth path: start with a compact installation and move toward a multi-node cloud without replacing the automation platform or rebuilding the application landscape.

More Than 75 Applications Behind One Login

The value of a large application catalog depends on how well those applications work together.

Infinito.Nexus therefore does not treat its more than 75 web applications as isolated installations. They are integrated into a common identity and access architecture built around a unified user database and central Single Sign-On.

Users authenticate once and can then access the applications assigned to them without managing a separate identity for every service. Depending on the capabilities of the respective application, Infinito.Nexus integrates it through OpenID Connect, OAuth2, LDAP or a protected trusted-header bridge.

The shared identity layer provides:

• One central user database
• One identity per person across the platform
• Central groups and role assignments
• Single Sign-On across the application landscape
• Centralized onboarding and offboarding
• Consistent administrative and user identities
• Reduced password duplication
• Application-specific access control
• Automated identity and credential provisioning

This architecture significantly reduces administrative overhead. A user does not need to be created manually in dozens of systems, and removing a user does not require administrators to search through the entire application landscape.

For employees and customers, the result is equally important: the cloud feels like one coherent digital environment rather than a loose collection of unrelated open-source products.

A Broad Cloud Catalog, Automated End to End

Most cloud platforms begin with infrastructure and leave application integration to the operator. Infinito.Nexus approaches the problem from the opposite direction: applications and their operational requirements are modeled together.

The catalog now contains more than 75 automated web applications and over 100 application-facing and platform-service roles.

It covers a broad range of use cases:

• Collaboration and communication
• File sharing and document editing
• Project and knowledge management
• Enterprise resource planning and customer relationship management
• Social networking and federated publishing
• Monitoring and observability
• Identity and access management
• Artificial intelligence and workflow automation
• Software development and source-code hosting
• Learning, media and event platforms
• Websites, content management and e-commerce
• Databases, search engines, queues and object storage

Organizations can deploy solutions such as Nextcloud, OpenProject, Matrix, GitLab, Gitea, Mattermost, WordPress, Moodle, Mastodon, ERPNext, Keycloak, BigBlueButton, Jitsi, Penpot and n8n through the same automation framework.

These applications are not delivered as independent containers that customers must integrate themselves. Infinito.Nexus automates their domains, TLS certificates, identity connections, databases, storage, networking, health checks, backups and deployment dependencies.

This breadth is central to the Infinito.Nexus vision. A sovereign cloud should not lock an organization into one predefined workplace. It should provide a reusable foundation on which different open-source solutions can be combined according to actual requirements.

Going Beyond openDesk at the Automation Layer

openDesk is an important open-source digital workplace with a scalable Kubernetes-based architecture. Its official documentation, however, states that databases and object storage included with the platform are intended for evaluation and must be supplied by the operator for production deployments. It also requires an existing Kubernetes environment and the associated operational tooling. See the openDesk architecture documentation.

With version 12.0, Infinito.Nexus goes beyond openDesk at this particular level: the breadth and depth of integrated infrastructure automation.

Infinito.Nexus does not automate only one predefined workplace suite. It provides a common deployment and identity model for more than 75 applications, together with the databases, storage systems, proxies, registries, monitoring services and backup infrastructure needed to operate them.

The platform can automatically provision PostgreSQL, MariaDB, Redis, Memcached, RabbitMQ, Elasticsearch, Typesense, Qdrant and Unbound. It can also provide object storage, shared filesystems, container registries, identity management, TLS, monitoring and backup services.

Applications can consume centrally operated services with separately provisioned credentials or retain their own embedded service when stronger isolation is preferable.

The comparison is not a claim that every individual Infinito.Nexus application replaces every openDesk integration. It means that Infinito.Nexus 12.0 covers a broader solution catalog and automates more of the supporting production infrastructure through one platform.

Backup Is Part of the Architecture

Scaling applications is only half the challenge. A distributed platform must also protect its state.

Infinito.Nexus 12.0 introduces a redesigned backup and disaster-recovery architecture. Backups are no longer defined indirectly through running containers. They are attached explicitly to the volumes that hold persistent data.

The new system can:

• Select backup policy individually for each volume
• Prefer filesystem snapshots when the host supports them
• Prepare btrfs hosts for snapshot-based backups automatically
• Protect volumes stored on the shared NFS service
• Back up platform secrets separately
• Synchronize backups to an external device when it is mounted
• Preserve ownership and storage consistency during recovery
• Quiesce distributed writers before restoring their data
• Restore services through one unified recovery command

Most importantly, the recovery path is tested automatically.

A backup that has never been restored is only an assumption. Infinito.Nexus performs recovery checks during deployment and runs a complete Swarm disaster-recovery drill in continuous integration. The drill exercises the path from application data through shared storage and backup media to restoration.

Backup technology is therefore part of the tested platform lifecycle—not an optional script that operators discover only after an incident.

Distribution-Agnostic by Design

Sovereignty also means avoiding unnecessary dependence on one operating-system vendor.

Infinito.Nexus is designed to work across the major Linux distribution families, including:

• Debian and Debian-based systems
• Arch Linux
• RHEL-family distributions

The automation resolves distribution-specific package names, repositories, service behavior and system requirements centrally. Applications continue to use a consistent deployment model even when the underlying host operating system changes.

This gives customers more freedom when selecting infrastructure. They can align the operating system with internal expertise, compliance requirements, existing contracts or the capabilities of their cloud provider.

The multi-distribution test matrix also helps prevent one platform from becoming an untested secondary target. Deployment and recovery paths are exercised across the supported distribution families.

Filesystem-Agnostic Infrastructure

The same principle applies to storage.

Infinito.Nexus 12.0 operates across ext4, btrfs and ZFS instead of requiring one specific filesystem. The platform detects the available capabilities and selects the appropriate behavior.

For example:

• ext4 provides a widely available and predictable baseline.
• btrfs enables native snapshot-based backup workflows.
• ZFS provides advanced storage, integrity and snapshot capabilities.
• NFS supplies shared storage across Swarm nodes.

The CI pipeline deliberately varies Docker’s data-root filesystem so filesystem-specific paths receive real coverage. Backup and recovery logic can take advantage of snapshot-capable storage without making snapshots a requirement for every installation.

Customers can therefore use the filesystem that best matches their environment while retaining a consistent deployment and recovery model.

Built for Failures, Not Just Successful Deployments

Distributed systems need useful answers when something goes wrong.

Version 12.0 introduces a unified diagnostic pipeline that collects evidence from every affected layer. Depending on the failure, this can include:

• System and kernel journals
• Resolver and network state
• Storage and device information
• PostgreSQL activity
• Docker and Swarm service status
• NFS-Ganesha thread state
• Container termination markers identifying the source of a SIGKILL
• Application and deployment logs

The resulting files are indexed and attached to CI runs, making failures easier to investigate without manually reconstructing the system state.

The CI pipeline itself has also become deployment-aware. Compose, Swarm and host deployments are planned separately. New roles receive priority, failed roles can be retriggered on the same distributions, and cancelled runs can have their unsuccessful jobs repeated. Failures on the main branch can automatically open or update role-specific issues.

A Cloud Platform That Can Grow with You

Infinito.Nexus 12.0 creates a clear progression for customers:

1. Start with an affordable single-server deployment.
2. Select the open-source applications required by the organization.
3. Connect them to one identity database and Single Sign-On.
4. Centralize databases, search engines and object storage where beneficial.
5. Add servers and distribute workloads through Docker Swarm.
6. Protect persistent data through automated backups and tested recovery.
7. Continue operating everything through one consistent automation model.

This reduces the gap between a small self-hosted installation and a scalable sovereign cloud.

The result is freedom at both ends of the spectrum: the freedom to begin without a large Kubernetes operation and the freedom to scale beyond one machine when demand increases.

Why It Matters

For Individual Customers

For an individual, a family or a small team, digital sovereignty has often required accepting significant complexity. Running several open-source applications meant configuring domains, certificates, users, databases, backups and updates separately.

Infinito.Nexus reduces that complexity.

An individual customer can begin with one server, select only the applications they need and access them through one identity. If requirements grow, the same environment can expand to additional machines without forcing a migration to an entirely different platform.

Automated backups and tested recovery also bring operational practices normally associated with larger organizations into smaller installations.

For Organizations

Organizations gain a standardized way to provide a broad application portfolio without creating a separate operations project for every product.

Central identity management improves security and simplifies onboarding and offboarding. Shared infrastructure reduces duplication. Multi-node deployment creates room for higher availability and horizontal growth. Distribution and filesystem independence preserve freedom when infrastructure or compliance requirements change.

Most importantly, organizations retain control over their data, identities and architecture.

For the Market

The cloud market is still dominated by vertically integrated platforms that combine software, identity, infrastructure and operations under one vendor’s control. Customers gain convenience but often lose portability and negotiating power.

Infinito.Nexus demonstrates another model.

A broad cloud portfolio can be assembled from open-source components while still delivering shared identity, automated deployment, scalable infrastructure, backup and recovery through one operational framework.

This changes the competitive perspective. The relevant question is no longer whether open-source applications exist. The question is whether they can be delivered with the consistency, scalability and operational maturity customers expect from proprietary cloud platforms.

Infinito.Nexus 12.0 is a substantial step toward answering that question with yes.

One Release, a Major Step Forward

Infinito.Nexus 12.0 is more than the introduction of Docker Swarm. It connects scalability, shared identity, central infrastructure, automated backup, disaster recovery, diagnostics and a large application catalog into one coherent platform.

For customers, that means:

• More than 75 applications behind one Single Sign-On
• One unified user and group database
• A path from one server to a multi-node cloud
• Support across Debian, Arch and RHEL-family distributions
• Operation across ext4, btrfs and ZFS
• Automated and continuously tested recovery
• Less infrastructure that must be assembled manually
• Greater control over data, architecture and future growth
• Less dependence on a single software vendor or cloud provider

The complete technical release notes, including all new roles, lifecycle promotions, fixes and dependency updates, are available in the Infinito.Nexus changelog.

Infinito.Nexus 12.0 brings us closer to a simple but ambitious goal: making a broad, integrated, scalable and resilient open-source cloud deployable through automation rather than assembled by hand.