Sponge

A powerful and easy-to-use Go development framework that enables you to effortlessly build stable, reliable, and high-performance backend services with a "low-code" approach.

Generate Convert Improve

Install / Use

/learn @go-dev-frame/Sponge

About this skill

Quality Score

0/100

README

English | 简体中文

</div>

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

Install Sponge: Supports Windows, macOS, Linux, and Docker environments. View the Sponge Installation Guide.
Open the Code Generation UI Page
```
sponge run
```
Access http://localhost:24631 in your local browser to generate code.
Example: One-click Generation of Web Service Backend Code Based on SQL
 <img width="750px" src="https://raw.githubusercontent.com/go-dev-frame/sponge/main/assets/en_sponge-ui.png"> 
- 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:

| Category | Component | |:-----------------------|:---------------------------------------------------------| | Frameworks | Gin, gRPC | | Database | GORM (MySQL, PostgreSQL, SQLite, etc.), MongoDB | | Cache/Messaging | Redis, Kafka, RabbitMQ | | Service Governance | Etcd, Consul, Nacos, Jaeger, Prometheus, OpenTelemetry | | Others | DTM (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.

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

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

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:

HTTP Service
 <img width="900px" src="https://raw.githubusercontent.com/zhufuyi/microservices_framework_benchmark/main/test/assets/http-server.png">
gRPC Service
 <img width="900px" src="https://raw.githubusercontent.com/zhufuyi/microservices_framework_benchmark/main/test/assets/grpc-server.png">

👉 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.

<details> <summary> 1. Monolith / Multi-Repo Structure Details. </summary>

   .
   ├── 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 dir

Related Skills

node-connect

334.1k

Diagnose OpenClaw node connection and pairing failures for Android, iOS, and macOS companion apps

frontend-design

82.1k

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

openai-whisper-api

334.1k

Transcribe audio via OpenAI Audio Transcriptions API (Whisper).

commit-push-pr

82.1k

Commit, push, and open a PR