Is Akka.Net going to be backward compatible over the years to come ?

[DSanchen]

We are about to design a SDK that will use inter process communication (IPC - either local on the same PC or remotely over a local network) from our customers programmed Client-App to our provided Server-App (we will also provide the customer some Client-Apps that are developed by us using the same SDK, running on the same Client PC).
We are planning to have at least three Assemblies: Client-Side Assembly (which will be in the NuGet Package that the Client-Apps reference), a Contracts Assembly (with the versioned payload Messages between Client and Server) that is referenced from both the Client-Side Nuget and the Server, and the Server-Assembly/ies that constitute the Server-Process (being a headless Servive-Process).

Will it be safe for us to evolve our Server-App using the ever newest Akka.Net NuGet and deploy it onto the customers Site without the customer having to recompile their Client-App (and thus using an older Akka.Net NuGet than the one, we are running in the Server-Process) ? The Client-App will very likely have a much slower evolution than our Server-App (sometimes being "back" for months or even years without being recompiled). At the same time we will very likely also evolve our own Client-Apps (that the client also uses alongside with their own ones...) that will benefit from the updated Server Version. So the "worst" case would even be a customer-app using an old Nuget (and Akka.Net) version at the same time that a client app uses a newer Nuget, with the same newer Akka.Net Version, that also the server Process uses.

I already watched the "Message and State Versioning in .NET (Using Akka.NET)" Video and understand that for this to work we need to provide our own Serializer using protobuf, and version our "over the wire" messages correctly.
But apart from that, how likely is the chance that a newer Version of Akka.Net on the Server-Process will fail to work with an older Version on the Client-Process ? Is there a possibility that the Akka.Net protocol "around" the versioned payload-messages is ever being changed ?
Putting it bluntly: Looking only at the IPC level between the two processes, which would be the "safer" choice, use gRPC or Akka.Net ?

Thanks for any Ideas !

[Aaronontheweb]

@DSanchen in the early part of this year we're going to publish our official version lifetime policies and so on, but the short answer is this:

Is there a possibility that the Akka.Net protocol "around" the versioned payload-messages is ever being changed ?

We are planning on radically redesigning this in v1.6 to solve several long-standing performance problems. Otherwise the wire format has been backwards compatible for 10 years. You can still opt-in to using that old wire format too.