📚 sponge - Awesome Go Library for Distributed Systems

Go Gopher mascot for sponge

A distributed development framework that integrates automatic code generation, gin and grpc frameworks, base development frameworks

🏷ī¸ Distributed Systems
📂 Distributed Systems
⭐ 0 stars
View on GitHub 🔗

Detailed Description of sponge

English | įŽ€äŊ“中文

Go Report codecov Go Reference Go Awesome Go License: MIT

Introduction

Sponge is a powerful and easy-to-use Go development framework. Built on the core philosophy of "Definition is Code", it aims to reshape the backend development experience through automatic generation technology, unleashing productivity and boosting development efficiency.

Sponge deeply integrates a code generation engine, Gin (Web framework), and gRPC (microservice framework), covering the full software lifecycle from project generation, development, and testing to API documentation and deployment.

Core Features:

  • Definition-Driven Development: Automatically parses SQL, Protobuf, and JSON configuration files to generate high-quality modular code.
  • LEGO-style Assembly: Flexibly combines code modules in a loosely coupled manner, supporting the rapid construction of monolithic applications, microservice clusters, and gateway services, including RESTful API, gRPC, HTTP+gRPC, gRPC Gateway, etc.
  • Low Code, High Efficiency: Eliminate the tedious, repetitive tasks of building underlying frameworks, developing CRUD operations, and configuring routing and governance. This allows developers to focus solely on core business logic and rapidly deliver standardized, high-quality backend services.

Why Choose Sponge?

  • Extreme Development Efficiency: One-click generation of complete, production-ready backend services, including CRUD, routing, documentation, and service framework code, multiplying development efficiency.
  • Out-of-the-box Toolchain: Provides a complete development toolchain (Generation → Business Logic → Testing → Deployment → Monitoring), eliminating the need to piece together fragmented tools.
  • Industry Best Practices: Built on the mainstream Go community tech stack (Gin/GORM/gRPC/Protobuf, etc.), with a standardized architecture to reduce technology selection risks.
  • Extremely Low Learning Curve: Easy to get started and beginner-friendly, while also meeting the customization needs of senior developers.
  • Ideal for Team Collaboration: Unifies project structure, improving team collaboration efficiency and code maintainability.
  • Flexible and Extensible: Supports custom templates, not limited to Go; capable of extending to frontend, test scripts, and other arbitrary code generation.
  • AI-Driven Development (AI-Native):
    • Sponge: automatically builds standardized infrastructure (API, data layer, service framework).
    • AI Assistant: analyzes project context and generates code intelligently fill in core business logic based on project context, achieving "Infrastructure Automation, Business Intelligence".

Applicable Scenarios

Sponge is suitable for building high-performance, maintainable backend systems, specifically for:

  • Rapid development of RESTful API services.
  • Building large-scale microservice architectures.
  • Cloud-native application development.
  • Rapid refactoring and migration of legacy projects.
  • Standardized engineering templates for Go beginners or teams.

Online Demo

No installation required, experience the code generation feature directly in your browser: Code Generation

Note: If you need to run the downloaded service code locally, you must first complete the local installation of Sponge.


Quick Start

  1. Install Sponge: Supports Windows, macOS, Linux, and Docker environments. View the Sponge Installation Guide.

  2. Open the Code Generation UI Page

    sponge run

    Access http://localhost:24631 in your local browser to generate code.

  3. Example: One-click Generation of Web Service Backend Code Based on SQL

    • Operation Process:
      • Fill Parameters: Connect to the database and select tables in the UI.
      • Download Code: Click generate and download the complete project package.
      • Generate Swagger Documentation: Execute make docs in the project root directory.
      • Start Service: Execute make run.
      • Test Interface: Access http://localhost:8080/swagger/index.html in the browser to test APIs via the Swagger interface.

Tech Stack & Components

Sponge follows the "batteries included" principle, integrating 30+ mainstream Go ecosystem components, loaded on demand:

CategoryComponent
FrameworksGin, gRPC
DatabaseGORM (MySQL, PostgreSQL, SQLite, etc.), MongoDB
Cache/MessagingRedis, Kafka, RabbitMQ
Service GovernanceEtcd, Consul, Nacos, Jaeger, Prometheus, OpenTelemetry
OthersDTM (Distributed Transaction), WebSocket, Swagger, PProf
......

👉 View the complete list of tech stacks and components.


Architecture & Principles

Code Generation Engine

Sponge provides multiple code generation engines, supporting built-in templates, custom templates, and AI-assisted generation.

  1. Code generation engine based on built-in templates, as shown below:


  1. Code generation engine based on custom templates, as shown below:


  1. Code generation engine based on AI-assisted business logic, as shown below:


Microservice Architecture

The code generated by Sponge follows a typical layered architecture with built-in service governance capabilities. The structure is clear and easy to maintain. The microservice framework structure of Sponge is shown below:


Performance Benchmarks

Based on tests with 50 concurrency and 1 million requests, services generated by Sponge demonstrate excellent performance:

  1. HTTP Service

  2. gRPC Service

👉 View detailed test code and environment.


Directory Structure

The service code directory structure created by Sponge follows the project-layout, supporting Monolith, Multi-Repo, and Mono-Repo patterns.

1. Monolith / Multi-Repo Structure Details. 
   .
   ├── api            # Directory for protobuf files and generated *pb.go files
   ├── assets         # Directory for other assets used with the repository (images, logos, etc.)
   ├── cmd            # Main application entry directory
   ├── configs        # Directory for configuration files
   ├── deployments    # Deployment scripts directory for bare metal, docker, k8s
   ├── docs           # Directory for design documents and interface documentation
   ├── internal       # Private application and library code directory
   │    ├── cache        # Cache directory wrapped based on business logic
   │    ├── config       # Go structure configuration file directory
   │    ├── dao          # Data access directory
   │    ├── database     # Database directory
   │    ├── ecode        # Custom business error code directory
   │    ├── handler      # HTTP business functionality implementation directory
   │    ├── model        # Database model directory
   │    ├── routers      # HTTP routing directory
   │    ├── rpcclient    # Client directory for connecting to gRPC services
   │    ├── server       # Service entry, including http, grpc, etc.
   │    ├── service      # gRPC business functionality implementation directory
   │    └── types        # HTTP request and response types directory
   ├── pkg            # Library directory that can be used by external applications
   ├── scripts        # Execution scripts directory
   ├── test           # Additional external test applications and test data
   ├── third_party    # Directory for dependent third-party protobuf files or other tools
   ├── Makefile       # Collection of commands related to development, testing, and deployment
   ├── go.mod         # Go module dependency and version control file
   └── go.sum         # Go module dependency checksum file
2. Mono-Repo Structure Details. 
   .
   ├── api
   │    ├── server1       # Protobuf files and generated *pb.go directory for Service 1
   │    ├── server2       # Protobuf files and generated *pb.go directory for Service 2
   │    ├── server3       # Protobuf files and generated *pb.go directory for Service 3
   │    └── ...
   ├── server1        # Code directory for Service 1, basically same structure as multi-repo
   ├── server2        # Code directory for Service 2, basically same structure as multi-repo
   ├── server3        # Code directory for Service 3, basically same structure as multi-repo
   ├── ...
   ├── third_party    # Dependent third-party protobuf files
   ├── go.mod         # Go module dependency and version control file
   └── go.sum         # Go module dependency checksum file

Documentation

Click to view the Official Sponge Documentation, covering core content such as development guides, components, service configuration, and deployment solutions.


Example Projects

Basic Examples

Advanced Projects


Contribution

Issues and PRs are welcome! Contribution Guide.


If Sponge is helpful to you, please give it a ⭐ Star! This will be our motivation for continuous updates.


← Back to Distributed Systems - Distributed Systems