Projects sharing features with Go Zero Looklook

This project is a reference implementation of a distributed system built using Spring Cloud Alibaba, Spring Boot, and JDK 17. It serves as a comprehensive model for implementing a microservices architecture. The system integrates a wide range of distributed patterns, including global transaction coordination for data consistency, OAuth2 and JWT for identity management, and Kubernetes-based container orchestration. It features a dedicated observability stack for distributed request tracing, log aggregation, and service health monitoring. The implementation covers several functional domains, i

Apache Dubbo Go is a Go language implementation of the Apache Dubbo framework designed for building high-performance microservices. It serves as a cross-language RPC framework and microservices communication layer that enables remote procedure calls between services written in different programming languages. The framework functions as a service governance toolset and a distributed service mesh proxy, allowing data planes to connect with external control planes in proxy or proxyless modes. It specifically provides a compatibility layer to facilitate communication between Go and Java-based ser

Jeesite is a full-stack low-code development framework designed for building enterprise administrative portals using Spring Boot, MyBatis, and Vue. It functions as a comprehensive platform for creating administrative dashboards with integrated role-based access control and organizational data permission systems. The framework distinguishes itself through a combination of automated CRUD code generation and an integrated RAG platform that connects large language models to enterprise data via vector stores. It further incorporates a BPMN-based workflow engine to automate complex business process

NATS Server is a high-performance, lightweight messaging system designed for cloud-native applications, edge computing, and distributed microservices. It functions as a distributed publish-subscribe broker that routes messages using hierarchical, dot-separated subject strings, enabling decoupled communication between services without requiring centralized broker lookups. The system supports core messaging patterns including asynchronous publish-subscribe, request-reply, and load-balanced queue processing. The platform distinguishes itself through a decentralized architecture that eliminates t

Moleculer is a Node.js microservices framework designed for building distributed systems. It functions as a distributed service broker, task orchestrator, and service mesh framework, enabling a decentralized architecture with built-in service discovery and load balancing. The project differentiates itself through a pluggable transport layer supporting protocols such as NATS, Redis, TCP, and Kafka, as well as a dedicated microservices API gateway that maps external HTTP and WebSocket requests to internal service actions. It includes built-in fault tolerance mechanisms, including circuit breake

This project is a microservice framework for building scalable backend systems in Go. It provides an architecture for distributed systems with integrated support for service discovery, load balancing, and fault-tolerance mechanisms. The framework distinguishes itself through a domain-driven layered architecture and a remote-first configuration system that synchronizes settings between remote stores and local files with automatic failover. It implements a high-performance communication model using gRPC for unary and streaming data exchange, as well as real-time notification systems for managin

Jupiter is a comprehensive suite for task scheduling, performance observability, service governance, project bootstrapping, and dependency analysis within service meshes. It provides a microservice governance framework to manage service discovery, load balancing, and communication across distributed systems. The project distinguishes itself through a service mesh management tool that analyzes service dependencies and manages multi-data center registration and runtime configuration. It includes a dedicated microservice project bootstrapper via a command-line tool to generate standardized proje

This project is a collection of reference implementations and demonstration projects covering computer vision, DevOps automation, distributed systems, and Java-based microservices. It provides a programming reference library and practical examples for building server-side applications, containerizing services, and orchestrating clusters. The repository features a comprehensive toolset for DevOps automation, including scripts and playbooks for CI/CD pipelines and automated cluster installation. It includes a computer vision demo project for image object detection and facial analysis, as well a

Gofr is a comprehensive framework for building production-ready microservices in Go. It provides a unified toolkit for developing RESTful APIs and gRPC services, offering built-in support for observability, database management, and distributed system communication. The framework distinguishes itself through its focus on developer productivity and system resilience. It automates common backend tasks such as CRUD handler generation, schema-driven code creation, and database migration orchestration, while preventing race conditions in clustered environments. To maintain stability, it includes in

This project is a comprehensive educational resource and curriculum focused on site reliability engineering, distributed systems, and infrastructure operations. It provides technical guides, a systems engineering course, and instructional manuals designed to teach the principles of managing large-scale computing environments. The curriculum covers high-level architectural design for scalability and resilience, including fault-tolerant infrastructure, high-availability patterns, and microservices decomposition. It emphasizes the practical application of site reliability engineering through the

SpringBoot-Labs is a collection of educational resources and reference implementations for Java backend architecture and distributed systems. It provides practical lab guides and code samples focused on building applications with the Spring Boot framework and designing scalable microservices architectures. The project specifically covers service governance and distributed cloud deployment patterns using Spring Cloud and Spring Cloud Alibaba. It includes a dedicated kit for microservices and a guide for executing remote procedure calls and managing service discovery via the Dubbo protocol. Th

This project is a distributed systems design framework and architecture guide. It provides technical resources for designing, deploying, and coordinating independent network services. The framework establishes a structured methodology for migrating monolithic applications into decentralized services by separating frontend and backend concerns. It serves as a reference for event-driven architecture, focusing on maintaining data consistency across network boundaries using event sourcing and local transaction records. The project covers a broad range of capabilities including distributed servic

This project is an integration framework that bootstraps Apache Dubbo remote procedure call services within Spring Boot applications. It serves as a microservice communication framework that enables the implementation of RPC services, service discovery, and distributed governance through automated configuration. The project distinguishes itself by providing a cross-language RPC bridge, allowing services written in different languages to communicate via standards such as gRPC and Protobuf. It further enables the exposure of backend microservices as REST endpoints using the Triple protocol for

Vector is a high-performance observability data pipeline designed to collect, transform, and route logs, metrics, and traces across distributed infrastructure. It functions as a modular engine that decouples data ingestion from processing and transmission, utilizing a component-based architecture to connect diverse sources to multiple destinations. The project distinguishes itself through a focus on reliability and flow control. It implements backpressure-aware data movement to prevent data loss during traffic spikes and utilizes disk-backed event buffering to ensure durability during network

rpcx is a high-performance remote procedure call framework for building scalable microservices in Go. It functions as a binary protocol RPC system and a service mesh, providing the necessary infrastructure for low-latency inter-service communication and distributed cloud environments. The project features a cross-language service gateway that provides an HTTP entry point, allowing clients written in any programming language to invoke Go remote services via protocol translation. It also includes a specialized RPC traffic analyzer for capturing and analyzing binary packets to debug network comm

SpringCloud-Learning is an educational project that demonstrates how to build microservices using Spring Cloud, covering the core patterns of service discovery, centralized configuration management, and API gateway routing. The project provides hands-on examples for registering and discovering microservice instances with Nacos, Eureka, or Consul, and for routing external API requests through Spring Cloud Gateway with support for filters and load balancing. The tutorials explore service resilience through circuit breakers and rate limiting with Sentinel and Hystrix, including custom fallback l

Nameko is a Python microservices framework designed for building distributed systems. It functions as an RPC communication framework and an event-driven architecture tool, using a message broker to decouple isolated service components. The framework provides a multi-protocol gateway that exposes internal microservice logic to external clients via HTTP endpoints and websockets. It enables the exchange of request-response messages and the broadcasting of asynchronous events to maintain data consistency across a distributed system. The system includes a command line interface for controlling an

Highly scalable realtime pub/sub and RPC framework

The Accidental CTO is a comprehensive collection of guides and frameworks focused on distributed systems architecture, resilience engineering, and system observability. It provides strategies for scaling applications from thousands to millions of users while maintaining high availability. The project offers specific methodologies for managing data volume through replication, sharding, and caching. It includes a framework for analyzing cloud infrastructure spending and evaluating transitions to self-hosted environments to reduce operational expenses. The resource covers the implementation of

godropbox is a backend development framework and service blueprint for building consistent server applications and microservices in Go. It provides a collection of shared libraries and patterns to standardize the development process across multiple projects. The project includes a dependency injection library that decouples business logic from implementations through interface-based service contracts. It also provides a suite of tooling for compiling and deploying Go applications as self-contained static binaries on Linux. The framework covers enterprise application tooling, including shared

Aidea is a cross-platform AI client and self-hosted infrastructure project. It consists of a Flutter application and a containerized backend system designed to provide a unified interface for interacting with large language models and AI image generation services. The project functions as a self-hosted AI gateway, allowing users to manage and deploy private instances of language and image models on their own hardware. This architecture enables the routing of diverse data queries through a standardized API gateway to multiple AI providers while maintaining control over data storage and server

This project is a Java microservices reference implementation that demonstrates the application of structural design patterns for distributed systems. It consists of a suite of containerized services and infrastructure dependencies designed to showcase how to coordinate multiple independent services into a functional system. The implementation focuses on several advanced architectural patterns, including a centralized API gateway for routing and aggregating responses, Command Query Responsibility Segregation to separate read and write operations, and event sourcing to persist the state of bus

Kratos is a toolkit for building cloud-native microservices in Go. It provides a comprehensive suite of framework primitives, including a dedicated toolset for API-first development using Protobuf to generate server and client code for gRPC and HTTP. The project is distinguished by its pluggable service infrastructure, which allows for the swapping of configuration stores, service registries, and data encoding formats. It utilizes a composable middleware pipeline to inject cross-cutting concerns such as authentication, request validation, and circuit breaking into the service flow. The frame

Dubbo is a Java RPC framework and microservices governance platform designed for high-performance remote procedure calls in distributed architectures. It provides the foundational components necessary to connect distributed services across a network, including a binary data serialization library and a distributed service registry. The platform distinguishes itself through a comprehensive governance suite that manages service discovery, load balancing, and traffic routing. It enables precise control over network traffic via conditional routing and a pluggable extension mechanism based on a ser

This project is a Java implementation of the try-confirm-cancel pattern, providing a distributed transaction framework and management library. It functions as a coordinator that manages the lifecycle of multi-phase transactions to ensure consistency across multiple distributed services. The framework includes a distributed transaction coordinator server that offloads event and task operations from local services. It also provides a dedicated dashboard for visualizing transaction status and manually operating distributed events and tasks. The system manages consistency through a three-phase c

Pinpoint is a distributed application performance monitoring and tracing system. It functions as an application performance monitor and topology visualizer designed to analyze the execution behavior of large-scale distributed applications. The system uses bytecode instrumentation to monitor applications without requiring changes to the original source code. It captures call stacks and request flows across interconnected services to visualize system dependencies and generate real-time architectural maps of communication patterns. The platform covers a broad range of observability capabilities

dtm is a distributed transaction framework and polyglot transaction coordinator designed to maintain data consistency across microservices. It functions as a Saga orchestration engine and a two-phase message coordinator, ensuring that multi-service operations either succeed completely or roll back to a consistent state. The project distinguishes itself by supporting multiple consistency patterns, including Saga, TCC, XA, and outbox patterns, allowing users to select the appropriate model for their specific application requirements. It provides a polyglot integration layer via HTTP and gRPC, e