IXWebSocket is a C++ library for client and server Websocket communication, and for client HTTP communication.

Following platforms are supported: * macOS * iOS * Linux * Android * Windows (no TLS)

Programming language: C++
Tags: Networking     Message Passing     Android     iOS     Windows     Linux     Osx     WebSocket     C++14    

IXWebSocket alternatives and similar libraries

Based on the "Networking" category

Do you think we are missing an alternative of IXWebSocket or a related project?

Add another 'Networking' Library



Alt text


WebSocket is a computer communications protocol, providing full-duplex and bi-directionnal communication channels over a single TCP connection. IXWebSocket is a C++ library for client and server Websocket communication, and for client and server HTTP communication. The code is derived from easywsclient and from the Satori C SDK. It has been tested on the following platforms.

  • macOS
  • iOS
  • Linux
  • Android
  • Windows


The ws folder countains many interactive programs for chat, file transfers, curl like http clients, demonstrating client and server usage.

Here is what the client API looks like.

ix::WebSocket webSocket;

std::string url("ws://localhost:8080/");

// Optional heart beat, sent every 45 seconds when there is not any traffic
// to make sure that load balancers do not kill an idle connection.

// Per message deflate connection is enabled by default. You can tweak its parameters or disable it

// Setup a callback to be fired when a message or an event (open, close, error) is received
webSocket.setOnMessageCallback([](const ix::WebSocketMessagePtr& msg)
        if (msg->type == ix::WebSocketMessageType::Message)
            std::cout << msg->str << std::endl;

// Now that our callback is setup, we can start our background thread and receive messages

// Send a message to the server (default to TEXT mode)
webSocket.send("hello world");

// The message can be sent in BINARY mode (useful if you send MsgPack data for example)
webSocket.sendBinary("some serialized binary data");

// ... finally ...

// Stop the connection

Here is what the server API looks like. Note that server support is very recent and subject to changes.

// Run a server on localhost at a given port.
// Bound host name, max connections and listen backlog can also be passed in as parameters.
ix::WebSocketServer server(port);

    [&server](std::shared_ptr<WebSocket> webSocket,
              std::shared_ptr<ConnectionState> connectionState)
            [webSocket, connectionState, &server](const ix::WebSocketMessagePtr msg)
                if (msg->type == ix::WebSocketMessageType::Open)
                    std::cerr << "New connection" << std::endl;

                    // A connection state object is available, and has a default id
                    // You can subclass ConnectionState and pass an alternate factory
                    // to override it. It is useful if you want to store custom
                    // attributes per connection (authenticated bool flag, attributes, etc...)
                    std::cerr << "id: " << connectionState->getId() << std::endl;

                    // The uri the client did connect to.
                    std::cerr << "Uri: " << msg->openInfo.uri << std::endl;

                    std::cerr << "Headers:" << std::endl;
                    for (auto it : msg->openInfo.headers)
                        std::cerr << it.first << ": " << it.second << std::endl;
                else if (msg->type == ix::WebSocketMessageType::Message)
                    // For an echo server, we just send back to the client whatever was received by the server
                    // All connected clients are available in an std::set. See the broadcast cpp example.
                    // Second parameter tells whether we are sending the message in binary or text mode.
                    // Here we send it in the same mode as it was received.
                    webSocket->send(msg->str, msg->binary);

auto res = server.listen();
if (!res.first)
    // Error handling
    return 1;

// Run the server in the background. Server can be stoped by calling server.stop()

// Block until server.stop() is called.

Here is what the HTTP client API looks like.

// Preparation
HttpClient httpClient;
HttpRequestArgsPtr args = httpClient.createRequest();

// Custom headers can be set
WebSocketHttpHeaders headers;
headers["Foo"] = "bar";
args->extraHeaders = headers;

// Timeout options
args->connectTimeout = connectTimeout;
args->transferTimeout = transferTimeout;

// Redirect options
args->followRedirects = followRedirects;
args->maxRedirects = maxRedirects;

// Misc
args->compress = compress; // Enable gzip compression
args->verbose = verbose;
args->logger = [](const std::string& msg)
    std::cout << msg;

// Synchronous Request
HttpResponsePtr out;
std::string url = "https://www.google.com";

// HEAD request
out = httpClient.head(url, args);

// GET request
out = httpClient.get(url, args);

// POST request with parameters
HttpParameters httpParameters;
httpParameters["foo"] = "bar";
out = httpClient.post(url, httpParameters, args);

// POST request with a body
out = httpClient.post(url, std::string("foo=bar"), args);

// Result
auto errorCode = response->errorCode; // Can be HttpErrorCode::Ok, HttpErrorCode::UrlMalformed, etc...
auto errorCode = response->errorCode; // 200, 404, etc...
auto responseHeaders = response->headers; // All the headers in a special case-insensitive unordered_map of (string, string)
auto payload = response->payload; // All the bytes from the response as an std::string
auto errorMsg = response->errorMsg; // Descriptive error message in case of failure
auto uploadSize = response->uploadSize; // Byte count of uploaded data
auto downloadSize = response->downloadSize; // Byte count of downloaded data

// Asynchronous Request
bool async = true;
HttpClient httpClient(async);
auto args = httpClient.createRequest(url, HttpClient::kGet);

// Push the request to a queue,
bool ok = httpClient.performRequest(args, [](const HttpResponsePtr& response)
        // This callback execute in a background thread. Make sure you uses appropriate protection such as mutex
        auto statusCode = response->statusCode; // acess results

// ok will be false if your httpClient is not async

Here is what the HTTP server API looks like. Note that HTTP server support is very, very recent and subject to changes.

ix::HttpServer server(port, hostname);

auto res = server.listen();
if (!res.first)
    std::cerr << res.second << std::endl;
    return 1;


If you want to handle how requests are processed, implement the setOnConnectionCallback callback, which takes an HttpRequestPtr as input, and returns an HttpResponsePtr. You can look at HttpServer::setDefaultConnectionCallback for a slightly more advanced callback example.

    [this](HttpRequestPtr request,
           std::shared_ptr<ConnectionState> /*connectionState*/) -> HttpResponsePtr
        // Build a string for the response
        std::stringstream ss;
        ss << request->method
           << " "
           << request->uri;

        std::string content = ss.str();

        return std::make_shared<HttpResponse>(200, "OK",



CMakefiles for the library and the examples are available. This library has few dependencies, so it is possible to just add the source files into your project. Otherwise the usual way will suffice.

mkdir build # make a build dir so that you can build out of tree.
cd build
cmake ..
make -j
make install # will install to /usr/local on Unix, on macOS it is a good idea to sudo chown -R `whoami`:staff /usr/local

Headers and a static library will be installed to the target dir. There is a unittest which can be executed by typing make test.


It is possible to get IXWebSocket through Microsoft vcpkg.

vcpkg install ixwebsocket


Support for building with conan was contributed by Olivia Zoe (thanks !). The package name to reference is IXWebSocket/5.0.0@LunarWatcher/stable. The package is in the process to be published to the official conan package repo, but in the meantime, it can be accessed by adding a new remote

conan remote add remote_name_here https://api.bintray.com/conan/oliviazoe0/conan-packages


There is a Dockerfile for running the unittest on Linux, and to run the ws tool. It is also available on the docker registry.

docker run bsergean/ws

To use docker-compose you must make a docker container first.

$ make docker
$ docker compose up &
$ docker exec -it ixwebsocket_ws_1 bash
app@ca2340eb9106:~$ ws --help
ws is a websocket tool

Implementation details

Per Message Deflate compression.

The per message deflate compression option is supported. It can lead to very nice bandbwith savings (20x !) if your messages are similar, which is often the case for example for chat applications. All features of the spec should be supported.


Connections can be optionally secured and encrypted with TLS/SSL when using a wss:// endpoint, or using normal un-encrypted socket with ws:// endpoints. AppleSSL is used on iOS and macOS, OpenSSL is used on Android and Linux, mbedTLS is used on Windows.

Polling and background thread work

No manual polling to fetch data is required. Data is sent and received instantly by using a background thread for receiving data and the select system call to be notified by the OS of incoming data. No timeout is used for select so that the background thread is only woken up when data is available, to optimize battery life. This is also the recommended way of using select according to the select tutorial, section select law. Read and Writes to the socket are non blocking. Data is sent right away and not enqueued by writing directly to the socket, which is possible since system socket implementations allow concurrent read/writes. However concurrent writes need to be protected with mutex.

Automatic reconnection

If the remote end (server) breaks the connection, the code will try to perpetually reconnect, by using an exponential backoff strategy, capped at one retry every 10 seconds. This behavior can be disabled.

Large messages

Large frames are broken up into smaller chunks or messages to avoid filling up the os tcp buffers, which is permitted thanks to WebSocket fragmentation. Messages up to 1G were sent and received succesfully.


  • On Windows TLS is not setup yet to validate certificates.
  • There is no convenient way to embed a ca cert.
  • No utf-8 validation is made when sending TEXT message with sendText()
  • Automatic reconnection works at the TCP socket level, and will detect remote end disconnects. However, if the device/computer network become unreachable (by turning off wifi), it is quite hard to reliably and timely detect it at the socket level using recv and send error codes. Here is a good discussion on the subject. This behavior is consistent with other runtimes such as node.js. One way to detect a disconnected device with low level C code is to do a name resolution with DNS but this can be expensive. Mobile devices have good and reliable API to do that.
  • The server code is using select to detect incoming data, and creates one OS thread per connection. This is not as scalable as strategies using epoll or kqueue.

C++ code organization

Here is a simplistic diagram which explains how the code is structured in term of class/modules.

+-----------------------+ --- Public
|                       | Start the receiving Background thread. Auto reconnection. Simple websocket Ping.
|  IXWebSocket          | Interface used by C++ test clients. No IX dependencies.
|                       |
|                       |
|  IXWebSocketServer    | Run a server and give each connections its own WebSocket object.
|                       | Each connection is handled in a new OS thread.
|                       |
+-----------------------+ --- Private
|                       |
|  IXWebSocketTransport | Low level websocket code, framing, managing raw socket. Adapted from easywsclient.
|                       |
|                       |
|  IXWebSocketHandshake | Establish the connection between client and server.
|                       |
|                       |
|  IXWebSocket          | ws://  Unencrypted Socket handler
|  IXWebSocketAppleSSL  | wss:// TLS encrypted Socket AppleSSL handler. Used on iOS and macOS
|  IXWebSocketOpenSSL   | wss:// TLS encrypted Socket OpenSSL handler.  Used on Android and Linux
|                       |                                               Can be used on macOS too.
|                       |
|  IXSocketConnect      | Connect to the remote host (client).
|                       |
|                       |
|  IXDNSLookup          | Does DNS resolution asynchronously so that it can be interrupted.
|                       |


Sending messages

websocket.send("foo") will send a message.

If the connection was closed and sending failed, the return value will be set to false.


getReadyState() returns the state of the connection. There are 4 possible states.

  1. ReadyState::Connecting - The connection is not yet open.
  2. ReadyState::Open - The connection is open and ready to communicate.
  3. ReadyState::Closing - The connection is in the process of closing.
  4. ReadyState::Closed - The connection is closed or could not be opened.

Open and Close notifications

The onMessage event will be fired when the connection is opened or closed. This is similar to the Javascript browser API, which has open and close events notification that can be registered with the browser addEventListener.

webSocket.setOnMessageCallback([](const ix::WebSocketMessagePtr& msg)
        if (msg->type == ix::WebSocketMessageType::Open)
            std::cout << "send greetings" << std::endl;

            // Headers can be inspected (pairs of string/string)
            std::cout << "Handshake Headers:" << std::endl;
            for (auto it : msg->headers)
                std::cout << it.first << ": " << it.second << std::endl;
        else if (msg->type == ix::WebSocketMessageType::Close)
            std::cout << "disconnected" << std::endl;

            // The server can send an explicit code and reason for closing.
            // This data can be accessed through the closeInfo object.
            std::cout << msg->closeInfo.code << std::endl;
            std::cout << msg->closeInfo.reason << std::endl;

Error notification

A message will be fired when there is an error with the connection. The message type will be ix::WebSocketMessageType::Error. Multiple fields will be available on the event to describe the error.

webSocket.setOnMessageCallback([](const ix::WebSocketMessagePtr& msg)
        if (msg->type == ix::WebSocketMessageType::Error)
            std::stringstream ss;
            ss << "Error: "         << msg->errorInfo.reason      << std::endl;
            ss << "#retries: "      << msg->eventInfo.retries     << std::endl;
            ss << "Wait time(ms): " << msg->eventInfo.wait_time   << std::endl;
            ss << "HTTP Status: "   << msg->eventInfo.http_status << std::endl;
            std::cout << ss.str() << std::endl;

start, stop

  1. websocket.start() connect to the remote server and starts the message receiving background thread.
  2. websocket.stop() disconnect from the remote server and closes the background thread.

Configuring the remote url

The url can be set and queried after a websocket object has been created. You will have to call stop and start if you want to disconnect and connect to that new url.

std::string url("wss://example.com");

Ping/Pong support

Ping/pong messages are used to implement keep-alive. 2 message types exists to identify ping and pong messages. Note that when a ping message is received, a pong is instantly send back as requested by the WebSocket spec.

webSocket.setOnMessageCallback([](const ix::WebSocketMessagePtr& msg)
        if (msg->type == ix::WebSocketMessageType::Ping ||
            msg->type == ix::WebSocketMessageType::Pong)
            std::cout << "pong data: " << msg->str << std::endl;

A ping message can be sent to the server, with an optional data string.

websocket.ping("ping data, optional (empty string is ok): limited to 125 bytes long");


You can configure an optional heart beat / keep-alive, sent every 45 seconds when there is no any traffic to make sure that load balancers do not kill an idle connection.