Orb is a framework for distributed systems development, it can be seen as the successor of go-micro.dev/v4.

This project is a work in progress, please do not use yet!

We are not far from the releasing the first Alpha, see the Roadmap.

With wire we gain:

• compile-time safety
• no more globals

It was the main reason for starting orb, wire allows us to decouple the components and plugins.

we have been working hard on removing all usage of reflect.

Orb allows you to listen on multiple port's with different protocols: gRPC, HTTP, HTTPS, DRPC, HTTP2, H2C, HTTP3. See the config system entry on howto configure it.

With orb you can configure your plugins with a config file or environment options.

service1:
  server:
    handlers:
      - Streams
    middlewares:
      - middleware-1
    entrypoints:
      - name: grpc
        plugin: grpc
        insecure: true
        reflection: false
  registry:
    enabled: true
    plugin: mdns
    timeout: 350
    domain: svc.orb

service1:
  server:
    handlers:
      - Streams
    middlewares:
      - middleware-1
      - middleware-2
    entrypoints:
      - name: hertzhttp
        plugin: hertz
        http2: false
        insecure: true

      - name: grpc
        plugin: grpc
        insecure: true
        reflection: false
        handlers:
          - ImOnlyOnGRPC
        middlewares:
          - ImAGRPCSpecificMiddlware

      - name: http
        plugin: http
        insecure: true

      - name: drpc
        plugin: drpc
  registry:
    plugin: consul
    address: consul:8500

These 2 config's with different options will both work, we first parse the config, get the "plugin" from it and pass a map[any]any with all config data to the plugin.

Both work with a single binary. :)

Return types as a result instead of HTTP req format.

New:

req := HelloRequest{Name: "test"}

// Look at resp, it's now returned as a result.
resp , err := client.Call[HelloResponse](context.Background(), clientDi, "org.orb.svc.hello", "Say.Hello", &req)

Old:

req := c.c.NewRequest(c.serviceName, "Greeter.Hello", in)
out := new(HelloResponse)
err := c.c.Call(ctx, req, out, opts...)
if err != nil {
  return nil, err
}
return out, nil

go-orb has support for sending nearly anything you throw in as application/json to the Server.

resp , err := client.Call[map[string]any](context.Background(), clientDi, "org.orb.svc.hello", "Say.Hello", `{"name": "Alex"}`, client.WithContentType("application/json"))

req := make(map[string]any)
req["name"] = "Alex"

resp , err := client.Call[map[string]any](context.Background(), clientDi, "org.orb.svc.hello", "Say.Hello", req, client.WithContentType("application/json"))

We like structured logging, this is why we replaced all logging with one based on slog.

We made sure that go-orb/go-orb (the core) is just a bunch of interfaces as well as some glue code, the most real code lives in go-orb/plugins.

Everything is linted and staticaly analyzed by golangcli-lint, enforced with CI/CD pipelines on github.

Chat with us on Discord.

• David Brouwer
• René Jochum

A lot of this is copy&pasted from go-micro, top contributors have been:

• Asim Aslam the founder/creator of go-micro.
• Milos Gajdos
• ben-toogood
• Vasiliy Tolstov
• Johnson C

go-orb is Apache 2.0 licensed and is based on go-micro.