Go Orb v0.3.0 Beta: Finally Here

Today I'm thrilled to announce the first beta release of Go Orb v0.3.0! This has been a labor of love since our initial commit on October 12, 2022 - yes, that's almost 2.5 years of development, testing, and refinement.

The Journey So Far

When I started working on Go Orb back in 2022, I wanted to create a successor to go-micro that addressed many of the architectural limitations and performance bottlenecks I encountered in real-world projects. The goal was ambitious: build a framework that could handle both monoliths and distributed systems with equal elegance, without sacrificing type safety or performance.

Fast forward to today, and I'm proud to say that Go Orb v0.3.0 Beta delivers on that promise.

What Makes Go Orb Special?

If you've been following the project, you know that Go Orb takes a fundamentally different approach compared to other Go frameworks:

1. Near-zero reflection: We've eliminated most runtime reflection for better type safety and performance.
2. Wire-based dependency injection: No more globals or runtime surprises - everything is wired up at compile time.
3. True plugin architecture: The core is just interfaces, with implementations living in plugins you can mix and match.

But v0.3.0 takes things to a whole new level with some exciting new features.

What's New in v0.3.0 Beta?

Registry API Overhaul

The registry is the beating heart of any distributed system, and we've completely redesigned ours:

// Find all instances of a service with specific metadata
nodes, err := registry.GetService(ctx, "app1", "eu-west", "auth.service")

We've added caching for faster lookups and native Unix socket support for high-performance local communication. The new filtering capabilities make it easy to target specific service instances based on metadata, version, or other criteria.

Streaming Support

One of the most requested features is now here - streaming:

stream, err := client.Stream(ctx, di, "data.service", "DataProcessor.Process")
if err != nil {
    return err
}

// Send data
err = stream.Send(data)

// Receive processed results
result, err := stream.Recv()

The streaming implementation works across memory, gRPC, and DRPC transports, with middleware support and proper context propagation. We've optimized it for high-throughput, low-latency scenarios, making it perfect for real-time data processing.

Context-Aware Components

All component lifecycle methods now accept a context, giving you better control over resource management:

// Before
err := component.Start()
// ...
err := component.Stop()

// Now
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
err := component.Start(ctx)
// ...
err := component.Stop(ctx)

This makes graceful shutdowns much more reliable and gives you fine-grained control over timeouts.

Unix Socket Support

For high-performance local communication, we've added Unix socket support across all transports:

[]client.Option{client.WithTransport("unix+drpc")}

Simplified Configuration

The configuration system has been redesigned as a merged map[string]any, making it much easier to access and manipulate:

config.Parse(nil, configSection, svcCtx.Config(), &cfg)

We've also introduced AppContext, ServiceContext, and ServiceContextWithConfig for better context management throughout your application.

Breaking Changes

Since this is a beta release, there are some breaking changes to be aware of:

• The Call() method has been renamed to Request() in the client API
• Service node structure now includes network type information
• Component lifecycle methods now require context parameters

Try It Today!

Ready to give Go Orb a spin? Getting started is easy:

Check out the examples repository for sample applications that demonstrate key features.

I'd love to hear your feedback! Feel free to open issues on GitHub, join our Discord, or reach out directly. This is a beta release, so your input will help shape the final v1.0.0 release.

Happy coding!

René