Fork me on GitHub

Ice - Comprehensive RPC Framework

What is Ice?

Ice is a comprehensive RPC framework with support for C++, C#, Java, JavaScript, Python, and more.

Object-Oriented RPC

With Ice, network interactions are operations called on remote objects. Familiar object-oriented idioms allow you to design elegant and powerful networked applications.

Improve Productivity

There is no need to worry about details such as opening network connections, serializing and deserializing data for network transmission, or retrying failed connection attempts (just to name a few things).

Language and Operating System Interoperability

Write your client in one language, your server in another, and run them on your favorite platforms. It's all seamless; your client and server are unaware of the language and platform the other is using.

Ice provides 100% native C++, C#, Java, and JavaScript implementations. Other languages leverage Ice for C++ to deliver improved performance.

module YellowPages
    class PersonDetails
       string phoneNumber;
       optional(1) string address;

    interface PhoneBook
        PersonDetails find(string name);

Intuitive IDL

Define the contract between your client and server using Ice's IDL, Slice.

Slice provides a rich set of data types that cleanly maps to all supported languages. User-defined types include enumerations, structures, sequences, and dictionaries, as well as classes and exceptions. Classes support pointer semantics, so complex graphs of objects can be passed over the wire.

Ice is Flexible

Make synchronous and asynchronous invocations using TCP, UDP, SSL/TLS, and WebSockets. Bidirectional connections allow a server to reuse a connection established by a client to make callbacks.

Synchronous and Asynchronous

Ice supports both synchronous (blocking) and asynchronous (non-blocking) invocations. With a synchronous invocation, the caller's thread blocks until the RPC has completed. An asynchronous invocation allows the caller to continue using the thread while the RPC is in progress and to be notified of the result.

On the server side, Ice supports both synchronous and asynchronous dispatch. The default is synchronous dispatch, where a server's thread reads the request, then locates and executes the implementation. With an asynchronous dispatch, the server's thread gives a callback to the implementation and is immediately available for additional requests. The implementation provides the result asynchronously through the callback.

Bidirectional Connections

An Ice connection normally allows requests to flow in only one direction. If your application requires the server to make callbacks to a client, the server usually establishes a new connection to that client in order to send a callback request. Network restrictions often prevent a server from being able to create a separate connection to the client, such as when the client resides behind a firewall.

A bidirectional connection offers a solution. Requests may flow in both directions over a bidirectional connection, allowing a server to send callback requests to a client over the client's existing connection to the server.

Code Generation

A Slice compiler will map each Slice type to a default type in the target language. You can also customize this mapping. For example, a Slice sequence<string> becomes by default a std::vector<string> in C++ and a String[] in Java. Slice metadata allows you to generate another compatible type, such as std::list<string> in C++ and java.util.List<String> in Java.

Dynamic Invocation and Dispatch

Besides static invocation and dispatch, which rely on compiled Slice definitions, Ice supports dynamic invocation and dispatch, which delay the decision as to which types are used for communication until run time. This feature permits you to create applications (such as routers and protocol bridges) that must deal with Slice types that are unknown at compile time.

Ice is Secure

Ice offers powerful and easy to use security features. The IceSSL plug-in uses your operating system's SSL/TLS stack to encrypt your data and authenticate your connections.

Data Security

IceSSL is simple and easy to use, requiring just a few lines of code to get started.

Learn more about using IceSSL

// Client configuration file.

Ice.Plugin.IceSSL=IceSSL:createIceSSL // Initialize IceSSL plug-in
IceSSL.CAs=cacert.pem                 // Certificate authority
IceSSL.CertFile=client.p12            // Client Certificate
// Client.cpp

// Stringified proxy for an object reachable through a wss endpoint
string strProxy = "hello:wss -h localhost -p 5064";

// Create a proxy from stringified representation
auto hello = Ice::checkedCast<HelloPrx>(communicator->stringToProxy(strProxy));

// sayHello over a secure websocket connection

Ice is Fast

Ice uses a compact, efficient binary protocol to minimize CPU and bandwidth consumption.

Efficient Binary Protocol

Ice was designed from the ground up for applications that require the utmost in performance and scalability. At the network level, Ice uses an efficient binary protocol that minimizes bandwidth consumption. Ice uses little CPU and memory, and its highly efficient internal data structures do not impose arbitrary size limitations. This allows applications to scale to tens of thousands of clients with ease.

For bandwidth-limited communication (such as over satellite channels), Ice provides protocol compression, which reduces the size of invocations to the absolute minimum. Compression can be enabled and disabled at run time and requires no code changes.

Request Forwarding

Ice applications can receive requests as opaque blobs of data and forward these requests to new destinations. This enables the creation of very efficient message routers, such as IceStorm or Glacier2, because messages can be forwarded without the need to unmarshal and remarshal their payloads.

Ice is Reliable

Create fault tolerant and load balanced deployments.

No Single Point of Failure

Ice allows you to create fault tolerant applications. Multiple instances of a server can be deployed on different machines, with transparent fail-over if a machine crashes or is disconnected from the network. This not only makes applications resilient against failures, but also increases performance because Ice allows you to balance the load of an application across multiple servers.

All Ice services can be replicated for fault tolerance, so they do not introduce a single point of failure.

Ice is Everywhere

Develop in C++, C#, Java, JavaScript, Objective-C, PHP, Python, and Ruby. Deploy on Linux, macOS, Windows, Android, iOS, and more.

Multi Language

Ice provides 100% native C++, C#, Java, and JavaScript implementations. Other languages leverage Ice for C++ to deliver improved performance.

Multi Platform

Ice runs on a wide range of platforms, from mainstream servers to smart phones and embedded devices.

Ice Services

Ice is more than a RPC framework. It also provides a number of complementary services for your networked applications.


Deployment and Monitoring


Firewall Traversal


Event Publish/Subscribe