# microsurging/surging

Surging is a micro-service engine that provides a lightweight, high-performance, modular RPC request pipeline.  support Event-based Asynchronous Pattern and reactive programming.

Repository: https://github.com/microsurging/surging
Canonical: https://ross.abutalabs.com/products/surging
Homepage: http://surging.kayakiot.cn:5173/
Language: C#
License: MIT
License Family: permissive
Topics: microservices, apigateway, surging, rabbitmq, messagepack, protobuffer, json-serialization, consul, zookeeper, log4net, kafka, redis, memorycache, nlog, swagger, kestrel, dns-server, skywalking, grpc, apollo
Last push: 2026-04-10T09:36:16+00:00

## Health v2 (maintenance only)
Score: 57/100 (v2, computed 2026-09-02T17:46:02.011165+00:00)
- activity 76, release rhythm 8, longevity 100
- inputs: {"age_days": 3365, "days_push": 145, "days_rel": null, "gap_med": null, "n_releases_24m": 0}
- flags: none
- formula: round(0.45*activity + 0.35*rhythm + 0.20*longevity); archived -> min(score, 10)

## Adoption (not part of the score)
Stars 3263, forks 921 (observed 2026-08-28T04:07:52.828211+00:00)

## What it is
Surging is a distributed microservice engine for .NET Core providing a lightweight, high-performance, modular RPC pipeline with service registration and discovery via ZooKeeper or Consul. It integrates load balancing, fault tolerance, an event bus, distributed caching, and supports transports like DotNetty, RabbitMQ, and gRPC with MessagePack or protobuf serialization.

## Use cases
- build microservices in .NET Core with RPC between services
- service registration and discovery with Consul or ZooKeeper
- add an API gateway in front of microservices
- publish/subscribe messaging via an event bus with RabbitMQ or Kafka
- load balancing and fault tolerance for internal service calls
- distributed caching with consistent hashing
- containerized CI/CD deployment of services on Docker and Kubernetes

## When to choose
- you are building a .NET Core microservice system needing high-performance RPC
- you want built-in service discovery, load balancing, and an event bus in one engine
- you prefer modular middleware (cache, eventbus, storage) with domain-driven service modules

## When to avoid
- your stack is not .NET/.NET Core
- you need a mainstream framework with a very large community and ecosystem (e.g., Service Mesh or ASP.NET Core + gRPC)
- you only need simple REST APIs without service mesh features

## Facets
- artifact type: framework
- maturity: active
- function: rpc, microservices, api-gateway, message-queue, serialization, caching, service-discovery, middleware, tracing
- domain: microservices, backend, apis
- platform: dotnet, cross-platform
- tags: dotnet-core, service-engine, event-bus, load-balancing, consul, zookeeper, netty, rabbitmq, grpc, skywalking, messaging, docker, kubernetes

## Member repositories
- microsurging/surging (main) score 57

## Provenance
- Observed fields: from GitHub, fetched 2026-08-28T04:07:52.828211+00:00.
- Health v2: computed from the inputs above; adoption is never an input.
- Inferred fields (summary, facets, guidance): AI-extracted, prompt v1, taxonomy v1, on 2026-08-29T18:43:51.675762+00:00, confidence not recorded.
  - readme: https://github.com/microsurging/surging (fetched 2026-08-28T04:07:52.828211+00:00, sha 4f70ca7d532e)
- Data as of 2026-08-30T08:39:29.467469+00:00.