Diffusion® Intelligent Event Data Platform

A holistic platform for event-driven
streaming data applications

- Consume any data
- Enrich in-flight
- Deliver efficiently

Bring new possibilities to your application!

Diffusion® makes it easy to consume, enrich and deliver event data to bring innovative solutions to market quicker

Diffusion Platform diagram

Build

All the functionality you need to quickly build any type of data driven application

  • Simple Integration
  • Multiple communication patterns
  • Supports all data structures and sizes
  • Built in network reliability functions

Scale

Scales effortlessly and enables you to decide what and where data is replicated

  • Distributed Live Data Model
  • Efficient Network Coordination
  • In-Memory Caching at the edge
  • Enterprise Grade Clustering

Innovate

More than just an API on the edge, Diffusion is backed by the latest innovation in:

  • Multi-Purpose Pub/Sub Model
  • Real-Time Key Value Store
  • Patented Session Broker
  • And more…

Secure

Ensures security over the edge and lets your business and not your systems dictate the level you secure at

  • Fine grained security control
  • Dynamic Security
  • Security Integrations

Cost

Built to not only make building applications simple and high performing, but to deliver these benefits in the most cost-effective way

  • Drive down development cost
  • Drive down infrastructure cost
  • Scale in the most cost-effective way
image/svg+xml Integrations Processing Operations Security Optimization Streaming In-Memory DB Distributed Connectivity Scale Delivery Unified API Integrations Processing Operations Security Optimization Connectivity Scale Delivery Unified API Streaming In-Memory DB Distributed

Distributed

Clustering:

Distribute data, security and connections in real-time across a local cluster, making it easier to reliably scale services horizontally.

Remote servers:

Create dynamic connections between Diffusion Clusters over a WAN, enabling global replication and hybrid deployments.

Edge replication:

Store data at the network edge for faster access, whilst also removing load from back-end systems.

Unified API

REST APIs:

Diffusion’s simple REST APIs enable quick integration of stateless applications, letting you scale real-time systems with minimal effort.

Rich clients:

Standardized client libraries make it easy to develop advanced real-time functionality within Web, Mobile, IoT & Desktop applications.

Administrative controls:

Manage service behavior and configuration in code, enabling deep integration with existing backend services.

Integrations

Prebuilt adapters:

Use pre-built adapters to start scaling and distributing real-time data from external services such as Kafka, JMS or REST in minutes.

Bespoke integrations:

Distributed coordination, state management, and partial updates make the integration of bespoke data sources simple.

Real-time fire hoses:

High-performance networking and flow-control ensures that you can reliably consume real-time data streams, regardless of throughput.

Streaming In-Memory DB

Real-Time Streams:

Combine real-time streams with historical data, allowing applications to query and respond to all events.

Data Agnostic:

Diffusion is completely data agnostic; stream text, JSON or binary data in any combination or format.

Topic Management:

Support millions of topics with dynamic application defined lifecycle rules, remove constraints around your data model.

Persisted:

Reliable disk-based persistence with cluster aware restoration, ensuring service resiliency.

Connectivity

Reliable Connections:

Automatic reconnection, failover and retransmission ensures your users are gracefully restored whenever there is a network issue.

Efficient Connectivity:

Delta compression enables you to deliver real-time data over any network including constrained ones, enabling you to deliver data anywhere.

Identity Management:

Identify and tag all connected sessions and users, enabling direct messaging, security control and cross device experiences.

Operations

Metrics:

Gain meaningful insights by exposing data, session and infrastructure metrics to industry standard real-time monitoring tools

Dashboard:

Configure, manage and report on connections, data, processing and security through a real-time UI platform.

Control API:

Expose every event inside Diffusion to an API for handling by back end services providing end to end control.

Processing

Mapping:

Dynamically combine and present real-time streams under different namespaces, making it easy to build application-specific views over changing data.

Transformation:

Restructure JSON values in-flight, enabling you to disaggregate and filter data, enabling you to deliver and secure data at a fine-grained level.

Delivery:

Apply conflation, throttling or delays to real-time streams, allowing you to fully control when applications are sent data.

Optimization

Deltas:

Diffusion automatically transmits only the changes between updates, resulting in bandwidth reductions of up to 99% - which means consistently faster delivery, more efficient scaling, and lower costs.

Flow control:

Diffusion’s networking layer adapts to congestion or slow responses, allowing clients to maintain connectivity across unpredictable networks.

Throttling/Conflation:

Control the rate of data delivery whilst ensuring slow consumers always receive the most recent updates, with intelligent, per-topic conflation policies.

Scale

High volume:

Remove constraints of scaling messages, connections and throughput, enabling you to deliver service at any scale with consistent performance.

Cache at edge:

Remove back end load by caching data on the edge, decoupling your clients from the back-end systems.

Auto-scaling:

Scale your platform to meet demands in real-time, enabling you to efficiently deploy resources.

Security

Auth integration:

Fully control your applications authentication flow with adaptors for standard and bespoke integration points.

Dynamic ACL:

Dynamically apply and modify topic level security enabling you to add and remove access in real-time.

TTL:

Establish automated rules over the lifecycle of data, making it easy to control when data is available.

Delivery

Pub/Sub:

One of four delivery mechanisms available inside Diffusion enabling you to publish real-time data to hundreds of thousands of consumers efficiently.

Request/Response:

Provide reliable one-off messaging between multiple endpoints allowing you to build sophisticated asynchronous interactions

Time Series:

Store real-time events and dynamically query historical data enabling you to replay past events at any point in time.

Fetch:

Retrieve snapshots from real-time streams and efficiently access static data through a simple query API.

Simplicity in Action

Our powerful real-time SDKs and Service API make building applications simple. See how easy it is to create streaming and REST based applications.

Pub/Sub

Request/Response

Time-Series

JS

.NET

Android

Apple

Java

C

Python

PHP

GO

REST

Publish

session.topics.add('my-topic',diffusion.topics.TopicType.JSON);
var value = { foo : 'bar' };
var result = session.topicUpdate.set('my-topic', diffusion.datatypes.json(), value);

Request

session.messages.sendRequestToFilter('$Principal is "alice"', 'account/offers', 'Special offer!', {
    onResponse : function(sessionID, response) {
        console.log("Received response " + response);
    },
    onResponseError : function() {
        console.log("There was an error when receiving the response");
    },
    ...
});

Publisher

session.topics.add('topic/timeseries', new TopicSpecification(TopicType.TIME_SERIES, {
    TIME_SERIES_EVENT_VALUE_TYPE : "json",
    TIME_SERIES_RETAINED_RANGE: "last 5h limit 100"
}))

for (let i = 0; i < 100; i++ ) {
    session.timeseries.append("topic/timeseries", { value: i }, diffusion.datatypes.json());
}

Response

session.messages.setRequestStream('account/offers', {
    onRequest: function(path, request, responder) {
        console.log('Received request: ' + request);
        responder.respond('Tell me more');
    },
    ...
});

Subscriber

const results = await session.timeseries.rangeQuery().as(diffusion.datatypes.json()).fromStart().limit(10).selectFrom("topic/timeseries");

result.events.forEach(event => {
    console.log("Got historic event: ", JSON.stringify(event));
});

Get Started Today!

Diffusion logo

Use Diffusion FREE to Build, Test &
Launch

Download Free
Diffusion Cloud logo

Use Diffusion Cloud FREE to Build, Test &
Launch

Sign Up Free

Check out the Diffusion Quick Start Guide to get up and running in minutes!

Quick Start Guide