twirp

That's what Twirp (https://github.com/twitchtv/twirp) is about. Protobuf or JSON, over any HTTP, with a simple URL schema. It's fairly simple.

Since we launched this last year, GitHub released a v2 of their internal cache API [0], based on Twirp [1] of all things, so we adapted to that. Interestingly that Twirp service also receives Actions artifacts, though we have not intercepted those today given that you likely still want them to appear in the GitHub UI / be accessible from the GitHub API. [0] https://github.com/actions/cache/discussions/1510 [1] https://github.com/twitchtv/twirp

There's two parts to gRPC's performance - 1. multiplexing protocol implemented on top of HTTP/2 - 2. serialization format via protobuf For most companies, neither 1 or 2 is needed, but the side effect of 2 (of having structured schema) is good enough. This was the idea behind twrip - https://github.com/twitchtv/twirp - not sure whether this is still actively used / maintained, but it's protobuf as json over HTTP.

ConnectRPC is very cool, thanks for sharing. I would like to add 2 other alternatives that I like: - dRPC (by Storj): https://drpc.io (also compatible with gRPC) - Twirp (by Twitch): https://github.com/twitchtv/twirp (no gRPC compatibility)

Twirp is lovely, we kind of hit a wall when using it internally because it doesn't have a streaming story: https://github.com/twitchtv/twirp/issues/3 If you don't need to stream data it is excellent.

I love protobufs as a type-safe way of defining messages and providing auto-generated clients across languages. I can't stand gRPC. It's such a Google-developed product and protocol that trying to use it in a simpler system (e.g. everyone else) is frustrating at best, and infuriating at worst. Everything is custom and different than what you're expecting to deal with when at its core, it is still just HTTP. Something like Twirp (https://github.com/twitchtv/twirp) is so much better. Use existing transports and protocols, then everything else Just Works.

Graphql is by far the most painful DX and least productive thing I've seen cargo-culted. Like most things there's a time and place for Graphql but I think it's vastly overused. For backend services in particular literally anything else is probably a better choice - rest, grpc, soap, a socket. I honestly don't know why more people don't give twirp a shot. https://github.com/twitchtv/twirp

I've used Twitch's Twirp before and it does that. It is a great middleground between gRPC and plain-HTTP services. :) https://github.com/twitchtv/twirp

Interesting! Level 0.5 seems to be what twirp[1], which I have used and enjoyed, would also fall under. [1]: https://github.com/twitchtv/twirp

The next time I want to build an API, I will probably make use of https://github.com/twitchtv/twirp. I like working with Protobuf and having strongly-typed and well-defined messages, but gRPC is way, way too much. It's obviously a Google product, built for what Google needs. Use Protobuf for messages, but just use HTTP for transport.

gRPC is so much cleaner and easier to work with for the APIs. - Error codes are well defined (vs "should I return 200 OK and error message as a JSON or return 40x HTTP code?") - no semantics ambiguity ("should I use POST for query with parameters that don't fit URL query param, or POST is only for modifying?") - API upgrades compatibility out of the box (protobuf fields identified by numbers, not names) Not to mention cross-platform support and autogenerating code. I use it in multiple Flutter+Go apps, with gRPC Web transparently baked in, and it just works. Once I had to implement chunked file upload in the app and, used to multiform upload madness, was scared even to start. But without all that legacy HTTP crap, implementing upload took like 10 mins. It was so easy and clean, I almost didn't believe that such a dreadful thing as "file u

Checkout Twirp, you get the good parts, protobufs and generated code, but its supports regular http, by no including streaming. https://github.com/twitchtv/twirp

Take a look at Twirp (https://github.com/twitchtv/twirp) open sourced by TwitchTv. It's a lot lighter weight than gRPC. It does use Protobufs but addresses some of the concerns you mentioned, such as being able to test with JSON payloads, works over HTTP 1.1 and HTTP/2, good client libraries, and doesn't require a proxy. They address your concerns in more detail in the Twirp release announcement (2018) - https://blog.twitch.tv/en/2018/01/16/twirp-a-sweet-new-rpc-f...

I think another differentiator is support for streaming. Tbh I am shocked at the number of folks that use streaming, but alas. It was the #3 issue opened on twirp repository, but they never settled on a solution. https://github.com/twitchtv/twirp/issues/3 One super underrated feature Connect offers for Go devs is access to the request/response headers. No more plumbing incoming/outgoing context :phew: