Hop3 - Open source platform as a service

Build status:

Hop3 is an open source platform as a service (PaaS): it enable you to deploy and manage your applications seamlessly. It is designed to be simple, secure, and easy to use.

The project is hosted on SourceHut and GitHub and Eclipse Research Labs.

• Status
• Getting Started
• Overview
• Goals
• Features (Including Planned Features)
  • Management and User Experience
  • Automation and Orchestration
  • Architecture and Design
• Technology Stack
• Supported OS
• Development and Contribution
  • Development Environment
  • Development and Delivery Pipeline
  • Contributing
  • Community Engagement
  • Additional Notes
• Roadmap
• Documentation
• Copyright, Credits and Acknowledgements
  • Authors
  • Licensing / REUSE Compliance
  • Funding
  • GenAI usage
• What's the story behind the name?
• Links / References

Hop3 is at version 0.6.x and under active development toward its 0.7 release. It can already deploy and manage real web applications — a curated set of self-hostable apps is being validated on it — but its APIs and internals are still changing.

Install the Hop3 server on the machine that will host your apps (Debian/Ubuntu/RHEL, run as root):

curl -LsSf https://hop3.cloud/install-server.py | sudo python3 -

Install the CLI on your own machine:

curl -LsSf https://hop3.cloud/install-cli.py | python3 -

Both installers are also published on PyPI as hop3-installer — run the toolkit straight from there (nothing to download) with uvx or pipx run:

uvx --from hop3-installer hop3-install cli          # CLI (no root)
pipx run --spec hop3-installer hop3-install cli     # same, with pipx

Run hop3-install server as root to install the server the same way.

The server installer accepts --domain example.com --acme-email you@example.com for a Let's Encrypt certificate, --with all to enable optional backing services (Redis, S3/MinIO) and runtimes (Docker, Nix), and more. Full reference: the installation guide.

Once installed, per-app configuration lives in each app's hop3.toml, and the full guides are at https://hop3.cloud.

Hop3 is an open-source platform designed to enhance cloud computing with a focus on sovereignty, security, sustainability, and inclusivity.

It aims to facilitate access to cloud technologies for a diverse range of users, including small and medium-sized enterprises (SMEs), non-profits, public services, and individual developers. By leveraging robust web, cloud, and open source technologies, Hop3 enables these groups to deploy and manage web applications efficiently and securely.

See also the following presentations:

• Hop3: Empowering Digital Sovereignty (OW2Con, June 2025)
• Hop3: Simplifying Cloud and Self-Hosting for Developers and SMEs (Open Source Experience, December 2024)

• Sovereignty: Empowers users to maintain control over their data and infrastructure, reducing reliance on centralized cloud services.
• Security and Privacy: Adopts a secure-by-design approach, integrating advanced security measures and ensuring compliance with privacy regulations like GDPR and the Cyber Resilience Act (CRA).
• Environmental Sustainability: Incorporates eco-design principles to reduce the environmental footprint of cloud computing, advocating for sustainable digital practices.
• Openness and Collaboration: Developed as an open-source project to encourage community-driven innovation and improvement.
• Inclusivity and Accessibility: Ensures the platform is accessible to a diverse audience, including those with different abilities, through comprehensive documentation and support.

Hop3 provides a comprehensive suite of features (some still in development) designed for robust application management, security, and intelligent automation.

• Centralized Web UI: A powerful web dashboard for managing applications, users, and system settings, complete with real-time analytics and event logs.
• User & Access Control: Integrates with LDAP for centralized authentication and supports Single Sign-On (SSO). A granular Role-Based Access Control (RBAC) system with audit logs allows for precise permission management.
• Domain & SSL Management: Simplifies DNS configuration and automates the entire lifecycle of SSL certificates with services like Let's Encrypt.

• Intelligent Orchestration Engine: A built-in engine that manages the deployment, scaling, and resource allocation of applications without requiring external tools like Kubernetes.
• Dynamic Scaling & Workload Management: Automatically scales applications based on demand and intelligently schedules tasks, including offloading heavy computations to more powerful infrastructure.
• Automated Lifecycle: Supports automated deployments through CI/CD integration, automated backups with disaster recovery capabilities, and seamless live migration of running services between nodes without downtime.

• Modular and Extensible: Built on a flexible, pluggable architecture that allows users to add and customize functionality with plugins.
• Distributed and Resilient: Utilizes a distributed, agent-based architecture for decentralized control, ensuring fault tolerance, high availability, and easy scalability.
• Comprehensive Security: Incorporates advanced security measures, including real-time monitoring, encryption for data at rest and in transit, and secure network management tools (firewalls, VPNs, etc.).

Hop3's technology stack is carefully chosen to support its goals without relying on conventional containerization tools like Docker or Kubernetes. Instead, it focuses on alternative, lightweight solutions that align with the project's principles of efficiency and sovereignty. The stack includes:

• Lightweight Isolation: Utilizes lean isolation technologies privided by POSIX operating systems, and improved by technologies such as Nix or Guix, to ensure efficient resource use and reproducible builds.
• Decentralized Architecture: Employs a decentralized model for data storage and processing to enhance sovereignty and resilience.
• Security Tools: Incorporates a suite of security tools designed for continuous monitoring, proactive threat mitigation, and compliance with the CRA.
• Energy-Efficient Computing: Adopts strategies and technologies aimed at minimizing energy consumption across all operations.
• Open Standards and Protocols: Committed to open standards to ensure interoperability and prevent vendor lock-in.

We aim to support a wide range of operating systems, including:

• Linux: Ubuntu, Debian, Archlinux, Rocky, Alma, Fedora, NixOS, Guix...
• BSD: FreeBSD, OpenBSD, NetBSD.

We run CI tests on the SourceHut platform, which supports a wide range of open source distributions and operating systems. This is a work in progress, and we welcome contributions to fix issues with the current tests or to expand the list of supported OS. See: .builds for the CI scripts, and https://builds.sr.ht/~sfermigier/ for current build status.

Contributions to Hop3 are highly encouraged, whether it involves fixing bugs, adding features, or enhancing documentation. The development and delivery pipeline is designed to be hermetic, reproducible, and highly responsive, integrating modern cross-platform functional package management with continuous integration/continuous delivery (CI/CD). This ensures that the development process is transparent, secure, and efficient.

To develop Hop3, you will need to set up a Python development environment (tested under various variants of Linux, and MacOS). The project uses Python 3.10+ and some common Python tools for environment and dependency management. We assume you are already familiar with these prerequisites.

• uv: You need uv installed. Run brew install uv or run the installer.
• nox: You need nox installed. Run uv tool install nox.

You can check your environment by running python3 scripts/check-dev-env.py or make check-dev-env, assuming you have make installed.

• NixOS/Nix: If using NixOS or Nix, you can use the provided shell.nix file to set up a development environment.

• Test Automation: We use nox for test automation. You can run nox to execute all tests, or nox -l to list available sessions.

• Development Tools: We use abilian-devtools for various development tasks. This includes make targets for common tasks, such as running tests, formatting code, and checking for typing issues. Run make help to see a list of the main available targets.

To ensure a hermetic, reproducible, and highly responsive internal delivery process, Hop3 integrates modern cross-platform functional package management with CI/CD. This approach leverages Nix to make the entire dependency tree transparent and validatable, enhancing the reliability and security of the delivery pipeline.

• Continuous Integration: Implement CI pipelines to automatically build and test code changes, ensuring that all code is continuously validated and ready for deployment.
• Continuous Delivery: Automate the deployment process to ensure that new features and updates can be delivered quickly and reliably to production.

• Nix Package Management: Use Nix for package management to achieve deterministic builds, minimize dependency conflicts, and ensure reproducibility. Nix provides a consistent environment for building and deploying applications, making it suitable for even the most critical environments.

• Software Bill of Materials (SBOM): Automatically generate compliance-ready CycloneDX Software Bill of Materials using tools like Genealogos. This ensures that all dependencies are transparent and verifiable, aiding in compliance and security audits.

Please refer to the following key documents for contribution guidelines:

• Getting Started
• Core Values
• Contributing
• Governance
• Code of Conduct
• Licenses

Engage with the Hop3 community:

• GitHub Issues: For bug reports and feature suggestions.
• Matrix Chat: Join the live discussion on Matrix at #hop3:matrix.org.

The following tools will soon be available:

• Community Forums/Discussion Boards: For discussions, questions, and community support.
• Mailing List: Subscribe to receive updates, announcements, and participate in discussions.

• Documentation: For detailed information on setup, architecture, and usage, refer to the docs folder. This resource includes comprehensive guides and best practices.
• Continuous Improvement: We welcome feedback and contributions from the community to continuously improve Hop3. Your participation is key to the success of this open-source project.

The current roadmap for Hop3 is available here.

See the docs directory for detailed information on Hop3's architecture, installation, and usage.

Deployed at https://hop3.cloud.

Hop3 contains code from Piku, which shares some of the goals of Hop3 / Nua but also has some significant differences in goals and principles, as well as in architecture (Hop3 is modular and pugin-based, Piku is a single-file script).

Hop3 also contains code from Nua, written by the Abilian development team, and contributors. The two projects share most goals and principles, except Nua is based on containers and Hop3 is not. The two projects may ultimately merge in the future (or not).

Other inspirations include:

• Dokku
• fig aka docker-compose

The following people have contributed to Hop3:

• Stefane Fermigier has created and maintains Nua and Hop3.

• Jérôme Dumonteil has contributed to and maintans Nua.

• Rui Carmo (and other Piku contributors) for the original Piku.

• Abilian is the company behind Nua and Hop3.

Hop3 is licensed under the Apache-2.0 License, except for vendored code. See the LICENSE file for more information.

Here are the REUSE compliance results for Hop3 (as of 2026/07/16):

❮ reuse lint
# SUMMARY

* Bad licenses: 0
* Deprecated licenses: 0
* Licenses without file extension: 0
* Missing licenses: 0
* Unused licenses: 0
* Used licenses: Apache-2.0, BSD-3-Clause, CC-BY-4.0, CC0-1.0, MIT
* Read errors: 0
* Invalid SPDX License Expressions: 0
* Files with copyright information: 2471 / 2471
* Files with license information: 2471 / 2471

This project is partly funded through the NGI0 Commons Fund, a fund established by NLnet with financial support from the European Commission's Next Generation Internet programme, under the aegis of DG Communications Networks, Content and Technology under grant agreement No 101135429. Additional funding is made available by the Swiss State Secretariat for Education, Research and Innovation (SERI).

More information here: https://nlnet.nl/project/Hop3-Nixified/

Generative AI is been used for specific tasks in this project:

• Code reviews, including security reviews.
• Generating some commit messages.
• Reviewing documentation for consistency and correct English.
• Large-scale refactorings, when standard tools

Tools we use include the (letscode coding agent), which we developped as a side-project to this project, and its plugins; a dedicated, soon to be published, security audit tool; and Claude and Pi, two popular coding agents, one of them Open Source. LLM we use include Devstral (from Mistral), Deepseek (Deepseek), GLM (Z.ai) and Opus (Anthropic).

All these tasks are driven, supervised, and, eventually, verified by a human.

"Hop3" (or more precisely "Hop^3" or "Hop cubed") is a pun on "Hop, hop, hop!" which is a French expression used to encourage quick action or to hurry someone up. It's akin to saying "Let's go!" or "Hurry up!" in English. It can also convey a sense of enthusiasm or encouragement to get moving or to proceed with something. It generally carries a light, motivating tone.

• Hop3 on PyPI
• Hop3 on GitHub
• Hop3 on SourceHut (mirror)
• Live Discussion
• Nua (Hop3's predecessor)
• Piku (Hop3's inspiration)
• Sailor (Another fork of Piku)
• Abilian (Hop3's sponsor -> buy support from us)
• Abilian SBE (One of the applications that can be deployed with Hop3 - Soon)