APNS Integration for iOS applications to reach an audience even when the app is backgrounded or not running

Guaranteed message delivery to ensure end users receive all messages intended for them

For zero penetration into your trusted enterprise network, the JMS 3.5 edition enables the ability to close all inbound firewall ports while still allowing Web users to connect

Offering volume-tiered data delivery services or to cap bandwidth utilization

Significantly lowered latency for better response time and decreased bandwidth to minimize data usage

The JMS 3.5 edition supports hybrid applications in addition to iOS Objective-C native applications

Kaazing WebSocket Gateway extends the reach of your JMS server to the Internet. Kaazing capitalizes on WebSocket to serve as a transport layer for higher-level protocols. Using standard JMS APIs, the client sends and receives JMS messages over the Web.

Unlike traditional solutions, the client does not need to go through an intermediary application server with HTTP to be translated to the real protocol on the back-end. The client is effectively communicating to the JMS broker directly.

Kaazing WebSocket Gateway can scale your back-end system far beyond its inherent capacity. The Gateway handles many client connections and shares subscriptions across them while using only a single connection to your messaging system. Hundreds of thousands of concurrent clients can be scaled horizontally putting minimal pressure on your messaging system.

Authenticate from a browser client or mobile device with the Kaazing WebSocket Gateway or your JMS message broker for secure access. Moreover, each operation they perform can also be authorized. For example, is a particular user allowed to subscribe to a particular topic?

Browser clients and mobile devices can publish and subscribe to topics that broadcast messages to many consumers. Subscriptions are multiplexed on a single connection, over the Web.

Browser clients and mobile devices can send and receive from queues. Subscriptions are multiplexed on a single connection, over the Web.

The Kaazing client libraries support both text and binary JMS messages over a WebSocket connection.

When connections are dropped the client automatically attempts to reconnect and resumes processing messages.

Automatically reconnect and resumes when the Kaazing WebSocket Gateway or JMS message broker restarts

Asynchronous message processing can be done through message listeners per destination or at the session level. Messages are delivered as they are received.

Messages are queued until requested by the application.

You can configure sessions for auto-acknowledgement or client-acknowledgement.

The flow of messages can be stopped and started per connection.

Messages can be sent and received with options for priority, expiration, and delivery mode (persistent or non-persistent).

The JMS client libraries support asynchronous request-response processing with correlation IDs and reply-to headers.

Using the Kaazing client libraries you can send and receive messages with custom properties. For example, properties can be used to send additional information or metadata and are included in the message.

In a client-server environment, JMS clients can initiate transactions. The client libraries supplied by Kaazing now bring this functionality to the Web. Transactions help ensure all messages are processed atomically.

Messages for slow consumers are buffered so that other clients continue processing at full speed.

The Kaazing WebSocket Gateway can extend the reach of any JMS-compatible broker to the Web, such as ActiveMQ, Informatica UMQ, and IBM MQ.

You can develop, test, and evaluate as much as you want for free. When you download Kaazing WebSocket Gateway it comes with a 50-connection free developer license. Other than that it is fully functional with no restrictions or time-limited features.

Go to the download page

Some of the HTML5 standards were designed to address the drawbacks of existing technology; HTML5 WebSocket is one such specification. Ajax and Comet are based on HTTP which was not designed for the requirements of modern-style browser applications.

HTML WebSocket is the next evolution in real-time communication over the Web, designed to be compatible with existing HTTP infrastructure, but without the limitations imposed by HTTP communication techniques.

The first thing most people notice about HTML5 WebSocket is that both the server and client can send data at any time, or even at the same time. This is in contrast to Ajax or Comet methods which rely on the client to regularly poll for data or perform other costly workarounds to simulate real-time communication.

Each message you send over a WebSocket has only two extra bytes to frame the beginning and end of the message. On the other hand, current HTTP communication such as Ajax or Comet include a large number of HTTP headers which are typically 1000 or more bytes. Therefore using HTML5 WebSocket can result in a drastic reduction in bandwidth, even on the order of 500x lower.

Any modern browser with native support for WebSocket can connect to the Gateway. But that's not all. Many environments can't or won't upgrade their browsers and Kaazing WebSocket Gateway makes sure they aren't left behind.

Kaazing's client emulation technology ensures older browsers can enjoy the benefits of Kaazing WebSocket Gateway with almost the same performance as native WebSocket. No plugins are required and browsers as old as Internet Explorer 6 are supported. Test it yourself by connecting to Kaazing.me with any browser.

Multiple levels of security for authentication, authorization, and encryption keep your data and your users safe — not just in the enterprise, but also over the Web. The HTML5 WebSocket specification has provisions for secure WebSocket connections. Kaazing WebSocket Gateway goes further offering a variety of authentication methods including the world's first implementation of Kerberos over WebSocket for secure authentication and authorization.

Modern browsers on mobile devices are also supported. For those without native WebSocket support, Kaazing's client emulation technology will let your applications run seamlessly.

You want to be able share the data from your back-end systems and applications over the Web without exposing them to everyone on the Internet. Kaazing WebSocket Gateway is ideal to place in the DMZ to act as a front-line access point for those back-end systems which can reside safely in the trusted network.

Allow cross-domain connections to your services and applications.

Fine-grained access control to specify which domains can access your services and applications. For example, you can have public services or a whitelist to only allow specific origin domains.

Manage and monitor Kaazing WebSocket Gateway connections and activity via JMX.

Get full JMS end-to-end communication, directly from the client to the message broker. Developers use the standard JMS API they are already familiar with to perform JMS operations, like publish and subscribe, in JavaScript. This allows you to connect standard Web applications to JMS message brokers transparently over WebSocket.

Get full JMS end-to-end communication, directly from the client to the message broker. Developers use the standard JMS API they are already familiar with to perform JMS operations, like publish and subscribe, in Adobe Flash, Flex, and Air in ActionScript. This allows you to connect standard Web applications to JMS message brokers transparently over WebSocket.

Get full JMS end-to-end communication, directly from the client to the message broker. Developers use the standard JMS API they are already familiar with to perform JMS operations, like publish and subscribe, in Java. This allows you to connect standard Web applications to JMS message brokers transparently over WebSocket.