A modular, extensible application framework for Go.

Hypercube is an experimental framework for building structured, maintainable Go applications with a focus on clear architecture, modularity, and developer experience.

The project is inspired by the ideas behind modern application frameworks, while embracing Go's simplicity, explicitness, and composition.

Hypercube aims to provide a small and reliable core that applications and third-party modules can build upon.

The framework is designed around a few fundamental concepts:

• Application — The central object that represents and bootstraps an application.
• Service Providers — The primary extension mechanism for registering and booting framework features and third-party modules.
• Configuration — A centralized approach to application configuration and environment management.
• Container — Dependency management and service resolution when needed.
• CLI — A framework-integrated command-line interface for interacting with and managing applications.
• Application Lifecycle — A predictable lifecycle for registering providers, booting the application, and running framework or application commands.

The goal is to keep the core small while allowing functionality such as migrations, databases, HTTP, authentication, queues, caching, and other capabilities to live in modular packages.

At a high level:

                    ┌─────────────────┐
                    │   Application   │
                    └────────┬────────┘
                             │
                             ▼
                    ┌─────────────────┐
                    │  App Lifecycle  │
                    └────────┬────────┘
                             │
              ┌──────────────┼──────────────┐
              ▼              ▼              ▼
       ┌────────────┐ ┌────────────┐ ┌────────────┐
       │  Config    │ │  Container │ │   CLI      │
       └────────────┘ └────────────┘ └────────────┘
                             │
                             ▼
                    ┌─────────────────┐
                    │ ServiceProvider │
                    └────────┬────────┘
                             │
              ┌──────────────┼──────────────┐
              ▼              ▼              ▼
       ┌────────────┐ ┌────────────┐ ┌────────────┐
       │  Database  │ │    Auth    │ │  Third-Party│
       │  Provider  │ │  Provider  │ │   Modules   │
       └────────────┘ └────────────┘ └────────────┘

Hypercube's core should provide the foundation and extension points, while features remain modular.

🚧 Early development

Hypercube is currently in the architectural and proof-of-concept stage.

The first goal is simple:

Prove that a Go application can be bootstrapped through the framework, have service providers registered and booted, and allow framework and third-party modules to contribute functionality through well-defined extension points.

The architecture will evolve as the project grows.

Hypercube follows a few principles:

• Keep the core small.
• Prefer explicit composition over magic.
• Make extension points clear.
• Keep framework features modular.
• Use Go's strengths rather than fighting the language.
• Design for maintainability and long-term architectural clarity.

Hypercube is currently evolving rapidly. If you're interested in the project, feel free to explore the repositories, open discussions, report issues, or contribute ideas.

More documentation and contribution guidelines will be added as the framework matures.

Hypercube — A modular application framework for Go.