TL;DR: Built an RPC framework that uses various approaches to solve existing RPC issues. Docs-only preview, seeking feedback before finalizing.

After seeing the same complaints about RPCs resurface for years, I spent the last year building a new RPC framework, AtomicLinkRPC (ALR).

The same article spawns heated discussions every few years:

https://reasonablypolymorphic.com/blog/protos-are-wrong/

And then the discussions based on that:

https://news.ycombinator.com/item?id=21871514

https://news.ycombinator.com/item?id=35281561

https://news.ycombinator.com/item?id=45139656

I've implemented a concrete, end-to-end answer to these issues and have published a docs-only preview (C++ first):

https://atomiclinkrpc.github.io/alr-preview/

Brief example:

  // service.h
  class Greeter : public alr::EndpointClass
  {
  public:
      static std::string sayHello(const std::string& name);
  };

  // service.cpp
  std::string Greeter::sayHello(const std::string& name)
  {
      return "Hello " + name;
  }

  int main()
  {
      return alr::ConnectionInfo()
          .setListenAddress("0.0.0.0:55100")
          .listen();
  }

  // client.cpp
  #include "alr/endpoint.h"
  #include "client_gen.h"

  int main()
  {
      alr::Endpoint ep = alr::ConnectionInfo()
          .setConnectAddress("service-host:55100")
          .connect();
  
      auto result = Greeter::sayHello("World"); // Happens to be RPC
  
      printf("%s\n", result.c_str());
      return 0;
  }

Below is a short list of issues brought up by the above discussions, and a brief description of how ALR solves each. I'd love your critique on what you think about these approaches, where you believe they'll break, and what's missing (but see the docs link for more in-depth details).

1) Impedance mismatch: App code contorts to fit the transport

- In ALR, "messages" and other RPC specific concepts become low-level implementation details, never to be seen by your business logic. Remotable classes, methods and structs stay clean from RPC noise and map 1:1 to your business logic.

- ALR uses an ambient variable system (see the docs), which is a set of thread-local variables that together provide all the context needed to perform RPCs without dragging context variables throughout your business logic. Only your own clean classes, clean functions, clean structs, and native types. No noise.

2) API evolution is broken, fragile, inconsistent or difficult to use and maintain in reality.

- ALR directly uses your classes, methods and structs as the schema, with no fragile tags.

- ALR negotiates schemas and visitor layout mapping at handshake time and creates an intersection map to allow different versions to interoperate.

3) Steep learning curve to understand and implement RPC frameworks

- Besides deriving your remotable class from an ALR base class, there isn't much new API to learn.

- Please check out the examples in the docs-preview link to get a feel for how easy it is to use compared to other frameworks.

4) Performance

- Benchmark results show that ALR can significantly outperform gRPC, see the results in docs. I'll be happy to discuss how those results are even possible.

Questions for HN

1. Do you see any flaws with ALR's approach to solving some of these issues?

2. If you have counterexamples where the dynamic remote capability check falls down, I want to hear them.

3. What RPC pain points am I missing that aren't addressed by ALR?

4. Any specific areas that need more detail here or in the docs?

Status & scope

- This is a docs-only preview. I'm seeking adversarial feedback before I freeze the interfaces.

- The source is not public yet while I finalize the open-source license.

- C++ is the first supported language, with plans for Python, Rust, and others.

Thanks for taking a look - blunt feedback welcome!

The Anti-Pitch

The Great Domestication: How Artificial Intelligence Is Remaking Consciousness

The Elegance of Movement in Silksong

Multiple undersea cable cuts in the Red Sea

Zodiac Sign Is 2000 Years Out of Date

Steve Jobs's Miracle Year

Willing to Fail

Docling simplifies document processing, parsing diverse formats

Cognition valued at $10.2B two months after Windsurf purchase

World Nuclear Association Welcomes Microsoft Corporation as Newest Member

Antitrust Litigation: PubMatic, Inc. vs. Google, LLC. 1:25-CV-01482 (E.D. VA.) [pdf]

Non-Constructive Arguments of Inevitability

The First Ziglang.org Outage

Why I'm lukewarm on graph neural networks

Ask HN: Feedback on a new framework aiming at the classic RPC headaches

Synthetic Data Toolkit Released on GitHub

Demystifying Tensor Parallelism

Novel – Notion-style WYSIWYG editor with AI-powered autocompletion

Apartment List US Rent Report

How a speedcubing world record holder does it

Show HN: Comparegpt.io – Spotting LLM hallucinations with multi-model comparison

Tony Hoare: How did software get so reliable without proof?

The Honesty Tax

Nvidia's Huang joining Trump on UK state visit next week

Birds and Frogs, thoughts on mathematicians by Freeman Dyson [pdf]

LWMalloc is a lightweight dynamic memory allocator for embedded systems

Spotify users ask for a setting to hide AI generated contents but they refuse

Hilbert space: treating functions as vectors

The Weird Death of User Interfaces (Enrico Tartarotti) [video]

I built an uptime monitoring tool in 3 weeks at 19

Show HN: My portfolio in the style of a campy early-internet Geocities site