---
title: "The Ice Framework"
description: "Guides, examples, and reference for building distributed applications with Ice."
url: https://docs.zeroc.com/ice/3.8
docs_index: https://docs.zeroc.com/llms.txt
---

> For an index of every page, see [llms.txt](https://docs.zeroc.com/llms.txt).

# The Ice Framework

Guides, examples, and reference for building distributed applications with Ice.

Ice is a complete RPC framework that helps you build networked applications with minimal effort.

- **Ice does the networking.** It takes care of opening network connections, serializing and deserializing data for network transmission, and retrying failed connection attempts, so you can focus on your application logic.
- **Start with the Greeter Example.** Writing a client-server application with Ice does not take much code. [See for yourself!](https://docs.zeroc.com/ice/3.8/greeter-example.md)

**C++**

```slice title="Greeter.ice"
module VisitorCenter
{
    /// Represents a simple greeter.
    interface Greeter
    {
        /// Creates a personalized greeting.
        string greet(string name);
    }
}
```

```cpp title="Client.cpp"
Ice::CommunicatorPtr communicator =
    Ice::initialize(argc, argv);
Ice::CommunicatorHolder holder{communicator};

VisitorCenter::GreeterPrx greeter{
    communicator,
    "greeter:tcp -h localhost -p 4061"};

string greeting = greeter.greet("alice");
cout << greeting << endl;
```

```cpp title="Server.cpp"
class Chatbot : public VisitorCenter::Greeter
{
public:
    string greet(
        string name, const Ice::Current&) override
    {
        return "Hello, " + name + "!";
    }
};

Ice::CommunicatorPtr communicator =
    Ice::initialize(argc, argv);
Ice::CommunicatorHolder holder{communicator};

auto adapter =
    communicator->createObjectAdapterWithEndpoints(
        "GreeterAdapter", "tcp -p 4061");
adapter->add(
    make_shared<Chatbot>(),
    Ice::Identity{"greeter"});
adapter->activate();
communicator->waitForShutdown();
```

**C#**

```slice title="Greeter.ice"
module VisitorCenter
{
    /// Represents a simple greeter.
    interface Greeter
    {
        /// Creates a personalized greeting.
        ["cs:identifier:Greet"]
        string greet(string name);
    }
}
```

```csharp title="Client.cs"
await using var communicator =
    new Ice.Communicator(ref args);

GreeterPrx greeter = GreeterPrxHelper.createProxy(
    communicator,
    "greeter:tcp -h localhost -p 4061");

string greeting =
    await greeter.GreetAsync("alice");
Console.WriteLine(greeting);
```

```csharp title="Server.cs"
class Chatbot : GreeterDisp_
{
    public override string Greet(
        string name, Ice.Current current) =>
        $"Hello, {name}!";
}

await using var communicator =
    new Ice.Communicator(ref args);

Ice.ObjectAdapter adapter =
    communicator.createObjectAdapterWithEndpoints(
        "GreeterAdapter", "tcp -p 4061");
adapter.add(
    new Chatbot(),
    new Ice.Identity { name = "greeter" });
adapter.activate();
await communicator.shutdownCompleted;
```

**Java**

```slice title="Greeter.ice"
["java:identifier:com.example.visitorcenter"]
module VisitorCenter
{
    /// Represents a simple greeter.
    interface Greeter
    {
        /// Creates a personalized greeting.
        string greet(string name);
    }
}
```

```java title="Client.java"
try (var communicator = new Communicator(args)) {
    var greeter = GreeterPrx.createProxy(
        communicator,
        "greeter:tcp -h localhost -p 4061");

    String greeting = greeter.greet("alice");
    System.out.println(greeting);
}
```

```java title="Server.java"
class Chatbot implements Greeter {
    @Override
    public String greet(
            String name, Current current) {
        return "Hello, " + name + "!";
    }
}

try (var communicator = new Communicator(args)) {
    ObjectAdapter adapter = communicator
        .createObjectAdapterWithEndpoints(
            "GreeterAdapter", "tcp -p 4061");
    adapter.add(
        new Chatbot(),
        new Identity("greeter", ""));
    adapter.activate();
    communicator.waitForShutdown();
}
```

**JavaScript**

```slice title="Greeter.ice"
module VisitorCenter
{
    /// Represents a simple greeter.
    interface Greeter
    {
        /// Creates a personalized greeting.
        string greet(string name);
    }
}
```

```js title="client.js"
await using communicator =
    new Ice.Communicator(process.argv);

const greeter = new VisitorCenter.GreeterPrx(
    communicator,
    "greeter:tcp -h localhost -p 4061");

const greeting = await greeter.greet("alice");
console.log(greeting);
```

**MATLAB**

```slice title="Greeter.ice"
["matlab:identifier:visitorcenter"]
module VisitorCenter
{
    /// Represents a simple greeter.
    interface Greeter
    {
        /// Creates a personalized greeting.
        string greet(string name);
    }
}
```

```matlab title="client.m"
communicator = Ice.Communicator(args);
cleanup = onCleanup(@() communicator.destroy());

greeter = visitorcenter.GreeterPrx( ...
    communicator, ...
    'greeter:tcp -h localhost -p 4061');

greeting = greeter.greet('alice');
fprintf('%s\n', greeting);
```

**PHP**

```slice title="Greeter.ice"
module VisitorCenter
{
    /// Represents a simple greeter.
    interface Greeter
    {
        /// Creates a personalized greeting.
        string greet(string name);
    }
}
```

```php title="Client.php"
$communicator = Ice\initialize($argv);

$greeter =
    VisitorCenter\GreeterPrxHelper::createProxy(
        $communicator,
        'greeter:tcp -h localhost -p 4061');

$greeting = $greeter->greet("alice");
echo "$greeting\n";
```

**Python**

```slice title="Greeter.ice"
module VisitorCenter
{
    /// Represents a simple greeter.
    interface Greeter
    {
        /// Creates a personalized greeting.
        string greet(string name);
    }
}
```

```python title="client.py"
async with Ice.Communicator(
    sys.argv, eventLoop=asyncio.get_running_loop()
) as communicator:
    greeter = VisitorCenter.GreeterPrx(
        communicator,
        "greeter:tcp -h localhost -p 4061")

    greeting = await greeter.greetAsync("alice")
    print(greeting)
```

```python title="server.py"
class Chatbot(VisitorCenter.Greeter):
    def greet(
        self, name: str, current: Ice.Current
    ) -> str:
        return f"Hello, {name}!"


with Ice.Communicator(sys.argv) as communicator:
    adapter = (
        communicator
        .createObjectAdapterWithEndpoints(
            "GreeterAdapter", "tcp -p 4061")
    )
    adapter.add(
        Chatbot(), Ice.Identity(name="greeter"))
    adapter.activate()
    communicator.waitForShutdown()
```

**Ruby**

```slice title="Greeter.ice"
module VisitorCenter
{
    /// Represents a simple greeter.
    interface Greeter
    {
        /// Creates a personalized greeting.
        string greet(string name);
    }
}
```

```ruby title="client.rb"
Ice::initialize(ARGV) do |communicator|
  greeter = VisitorCenter::GreeterPrx.new(
    communicator,
    "greeter:tcp -h localhost -p 4061")

  greeting = greeter.greet("alice")
  puts greeting
end
```

**Swift**

```slice title="Greeter.ice"
module VisitorCenter
{
    /// Represents a simple greeter.
    interface Greeter
    {
        /// Creates a personalized greeting.
        string greet(string name);
    }
}
```

```swift title="Client.swift"
var args = CommandLine.arguments
let communicator = try Ice.initialize(&args)
defer { communicator.destroy() }

let greeter = try makeProxy(
    communicator: communicator,
    proxyString:
        "greeter:tcp -h localhost -p 4061",
    type: GreeterPrx.self)

let greeting = try await greeter.greet("alice")
print(greeting)
```

```swift title="Server.swift"
struct Chatbot: Greeter {
    func greet(
        name: String, current _: Ice.Current
    ) -> String {
        "Hello, \(name)!"
    }
}

var args = CommandLine.arguments
let communicator = try Ice.initialize(&args)
defer { communicator.destroy() }

let adapter = try communicator
    .createObjectAdapterWithEndpoints(
        name: "GreeterAdapter",
        endpoints: "tcp -p 4061")
try adapter.add(
    servant: Chatbot(),
    id: Ice.Identity(name: "greeter"))
try adapter.activate()
await communicator.shutdownCompleted()
```

## Explore the Documentation

If you're new to Ice, start with the Greeter Example, then Basics. The cards below are the main chapters; the table of contents in the sidebar lists them all. To find a page by name, use the search box in the top bar or press `Ctrl+K`, or `⌘K` on macOS.

- [Greeter Example](https://docs.zeroc.com/ice/3.8/greeter-example.md): Build your first Ice application, step by step, in your language.
- [Basics](https://docs.zeroc.com/ice/3.8/basics.md): How Ice applications are structured, and the terms and ideas the rest of the manual builds on.
- [The Slice Language](https://docs.zeroc.com/ice/3.8/slice.md): Define the interfaces, operations, and data types your clients and servers share.
- [The Ice Runtime](https://docs.zeroc.com/ice/3.8/runtime.md): Call remote objects, implement your own, and configure connections, threads, and security.
- [Ice Services](https://docs.zeroc.com/ice/3.8/services.md): Reach servers behind a firewall, start servers on demand, and distribute events and data.
- [Property Reference](https://docs.zeroc.com/ice/3.8/property-reference.md): Every property the Ice runtime and its services understand.

## Releases

- **Ice 3.8.3** (September 10, 2026): [Release notes](https://docs.zeroc.com/ice/3.8/releases/ice-3-8-3/release-notes.md), [Supported platforms](https://docs.zeroc.com/ice/3.8/releases/ice-3-8-3/supported-platforms.md)
- **Ice 3.8.2** (June 4, 2026): [Release notes](https://docs.zeroc.com/ice/3.8/releases/ice-3-8-2/release-notes.md), [Supported platforms](https://docs.zeroc.com/ice/3.8/releases/ice-3-8-2/supported-platforms.md)
- **Ice 3.8.1** (March 3, 2026): [Release notes](https://docs.zeroc.com/ice/3.8/releases/ice-3-8-1/release-notes.md), [Supported platforms](https://docs.zeroc.com/ice/3.8/releases/ice-3-8-1/supported-platforms.md)
- **Ice 3.8.0** (December 17, 2025): [Release notes](https://docs.zeroc.com/ice/3.8/releases/ice-3-8-0/release-notes.md), [Supported platforms](https://docs.zeroc.com/ice/3.8/releases/ice-3-8-0/supported-platforms.md)

- **[Upgrade Guide](https://docs.zeroc.com/ice/3.8/upgrade-guide.md)** Moving an application from Ice 3.7 to Ice 3.8.
- **[Backward Compatibility of Ice Versions](https://docs.zeroc.com/ice/3.8/compatibility.md)** What a patch, minor, or major release keeps compatible.

## Beyond the Documentation

- **API reference** for [C++](https://code.zeroc.com/ice/3.8/api/cpp/index.html), [C#](https://code.zeroc.com/ice/3.8/api/csharp/index.html), [Java](https://code.zeroc.com/ice/3.8/api/java/index.html), [JavaScript](https://code.zeroc.com/ice/3.8/api/javascript/index.html), [PHP](https://code.zeroc.com/ice/3.8/api/php/index.html), [Python](https://code.zeroc.com/ice/3.8/api/python/index.html), [Ruby](https://code.zeroc.com/ice/3.8/api/ruby/index.html), and [Swift](https://code.zeroc.com/ice/3.8/api/swift/documentation/), plus the [Slice definitions](https://code.zeroc.com/ice/3.8/api/slice/index.html) that ship with Ice.
- **[Demos on GitHub](https://github.com/zeroc-ice/ice-demos/tree/3.8)** Sample programs for every language mapping.
- **[Ice on GitHub](https://github.com/zeroc-ice/ice)** Source code, issue tracker, and the [changelog](https://github.com/zeroc-ice/ice/blob/3.8/CHANGELOG-3.8.md) of each release.
- **[IceRPC](https://docs.icerpc.dev/)** ZeroC's new RPC framework. See [Using Ice and IceRPC Together](https://docs.zeroc.com/ice/3.8/icerpc.md).