awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
evrone avatar

evrone/go-clean-template

0
View on GitHub↗

Go Clean Template

Clean Architecture template for Golang services

Features

  • Clean Architecture Implementations - Builds maintainable Go services with clean architecture, separating business logic from infrastructure through dependency injection and interface-based design.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI
  • Repository Pattern with Swap Support - Abstracts all data access behind repository interfaces so that swapping PostgreSQL for MongoDB or in-memory storage requires zero changes to business logic.
  • Explicit Dependency-Injection Wiring - Wires the entire application graph in a single main function using constructor calls and interface parameters.
  • Interface-Based Decoupling - Defines repository and use-case boundaries as Go interfaces so that the core domain never imports infrastructure packages directly.
  • API Services - Exposes the same business logic simultaneously over REST, gRPC, AMQP RPC, and NATS RPC without duplicating handler code.
  • Three-Layer Clean Architecture - Structures code into delivery, use-case, and repository layers with strict inward-only dependency rules enforced by the project layout.
  • Explicit Dependency-Injection Wiring - Wires the entire application graph in a single main function using explicit constructor calls and interface parameters.
  • Transport-Agnostic Use Cases - Exposes the same business logic through multiple transport protocols by keeping use-case interfaces free of any transport-specific types.
  • Business Logic Isolation - Injects dependencies through interfaces so that swapping databases or frameworks never touches the core domain code.
  • JWT Authentications - Authenticates requests by validating signed JSON Web Tokens in middleware, with configurable expiry and bcrypt-hashed password storage.
  • 7,601 stars·657 forks·Go·MIT·16 views

    Star history

    Star history chart for evrone/go-clean-templateStar history chart for evrone/go-clean-template

    How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

    Projects sharing features with Go Clean Template

    These projects share indexed features with Go Clean Template. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
    • amitshekhariitbhu/go-backend-clean-architectureamitshekhariitbhu avatar

      amitshekhariitbhu/go-backend-clean-architecture

      6,059View on GitHub↗

      This is a Go backend template that structures a web service into domain, usecase, controller, and repository layers with strict dependency inversion. It provides a foundation for building maintainable and testable REST APIs by separating business logic from transport and data access concerns. The project implements JWT-based authentication, issuing access and refresh tokens for user signup, login, and protected endpoint access. It uses the Gin HTTP framework to build a Docker-packaged REST API with public and private route groups, request validation, and middleware-based authentication. Depen

      Goapiarchitecturebackend
      View on GitHub↗6,059
    • bxcodec/go-clean-archbxcodec avatar

      bxcodec/go-clean-arch

      10,118View on GitHub↗

      This project is a boilerplate and template for Go applications implementing Clean Architecture. It provides a standardized project structure designed to organize code into decoupled layers, ensuring that core business logic remains independent of databases, frameworks, and user interfaces. The implementation focuses on a domain-driven design that utilizes dependency injection and the repository pattern to abstract data storage. It enforces architectural boundaries through internal package encapsulation and layer-based dependency inversion. The project includes a development toolchain that au

      Goarchitecturearticleclean-architecture
      View on GitHub↗10,118
    • threedotslabs/wild-workouts-go-ddd-exampleThreeDotsLabs avatar

      ThreeDotsLabs/wild-workouts-go-ddd-example

      6,348View on GitHub↗

      This project is a reference implementation of Domain-Driven Design, Clean Architecture, and Command Query Responsibility Segregation (CQRS) patterns using the Go programming language. It serves as a sample application to demonstrate how to decouple core domain rules from infrastructure and delivery mechanisms. The system is built as a gRPC microservices architecture, utilizing type-safe communication and service contracts. It implements an event-driven architecture to manage eventual consistency and asynchronous processing, specifically employing the Outbox pattern to ensure reliable messagin

      Goclean-architecturecqrsddd
      View on GitHub↗6,348
    • bespoyasov/frontend-clean-architecturebespoyasov avatar

      bespoyasov/frontend-clean-architecture

      2,575View on GitHub↗

      This project provides a structural pattern for organizing React and TypeScript applications by decoupling business logic from user interface components and external infrastructure. It implements a layered architecture that isolates core domain rules, ensuring that the application remains independent of specific frameworks, libraries, or external service implementations. The architecture relies on dependency injection and inversion principles to manage service implementations, allowing for modularity and easier testing. By utilizing a functional core and imperative shell, the system separates

      TypeScriptadaptersapplicationclean-architecture
      View on GitHub↗2,575
    Compare all 30 related projects→

    Frequently asked questions

    What does evrone/go-clean-template do?

    Clean Architecture template for Golang services

    What are the main features of evrone/go-clean-template?

    The main features of evrone/go-clean-template are: Clean Architecture Implementations, Repository Pattern with Swap Support, Explicit Dependency-Injection Wiring, Interface-Based Decoupling, API Services, Three-Layer Clean Architecture, Transport-Agnostic Use Cases, Business Logic Isolation.

    Which projects share features with evrone/go-clean-template?

    Projects with overlapping indexed features include: amitshekhariitbhu/go-backend-clean-architecture — This is a Go backend template that structures a web service into domain, usecase, controller, and repository layers… bxcodec/go-clean-arch — This project is a boilerplate and template for Go applications implementing Clean Architecture. It provides a… threedotslabs/wild-workouts-go-ddd-example — This project is a reference implementation of Domain-Driven Design, Clean Architecture, and Command Query… bespoyasov/frontend-clean-architecture — This project provides a structural pattern for organizing React and TypeScript applications by decoupling business… mattia-battiston/clean-architecture-example — This project is a reference implementation for structuring Java applications using clean architecture and… khannedy/golang-clean-architecture — This project provides a structured boilerplate for building Go web applications based on clean architecture…