deephaven.io Open in urlscan Pro
2606:4700:20::ac43:442b  Public Scan

Form analysis
0 forms found in the DOM

Text Content

Skip to main content
Products
 * Community Core
   For individuals and small teams. Includes the Deephaven query engine, APIs
   and web viewers.
 * Enterprise
   For larger deployments. Includes accounts, ACLs, multiple workers,
   scheduling, dedicated support, dashboards, and more.
 * Barrage
   Apache Arrow Flight extension to support ticking datasets via IPC.
 * Data Grid
   React.js data grid for rendering billions of rows and columns.
 * CSV Parser
   High-performance, column-oriented, type inferencing CSV parser.
 * Professional Services
   Extra muscle to help you build your infrastructure, set up your pipelines,
   and optimize your queries.

Company
 * About
 * Solutions
 * Newsroom
 * Careers

Docs
 * Community Docs
   Learn how to explore data, transform streams, query streaming tables and
   build real-time apps.
 * Enterprise Docs
   Learn to write efficient queries, explore dynamic data, and create
   interactive dashboards with Deephaven Enterprise.
 * Getting Started
 * Quickstart
 * Crash course
 * Community cheat sheet
 * Important Concepts
 * Deephaven overview
 * Technical building blocks
 * Table update model
 * Directed-acyclic-graph
 * API Reference
 * Pydoc (client)
 * Pydoc (server)
 * Javadoc (client/server)
 * Godoc (go client)
 * C++ (client)
 * R (client)
 * Other Projects
 * Barrage docs
 * Grid docs
 * CSV parser

BlogTry Demo
SearchK



SERIOUS
REAL‑TIME
DATA TOOLS

Query engine, APIs & user interfaces for modern real-time workloads.

Try Live Demo

or start with docker

11/t = quotesAll.aj(quotesSpy, "Timestamp", "WtdMid_Spy = WtdMid")\
.updateView("Ratio = WtdMid_Spy / WtdMid")
Deephaven has been battle-tested inside prominent hedge funds, investment banks,
and stock exchanges, managing billions in assets. Every day.

DATA SYSTEM

Deephaven is an open-core* framework and query engine for working with streaming
tables. Use dynamic data in tables with the same ease as static dataframes.


DATA SOURCES

Access and ingest data directly from popular, standard formats. For example, use
a Kafka event stream alongside historical Parquet data.


DATA PROCESSING

Stream updating and real-time derived data to consumers. Connect JavaScript,
Python, Java, and C++ clients and receive live updates or snapshots. Write to
persistent stores. Build and share real-time visualizations and monitors.
Explore massive and ticking datasets with built-in tools. Connect enterprise
apps.


DATA CONSUMERS

Exhaust new streams or write to persistent stores, build and share real-time
visualizations and monitors. Explore massive and ticking datasets with built in
tools. Build enterprise apps.

WHY DEEPHAVEN?


STREAMING DATA
DONE RIGHT


SERIOUS
PERFORMANCE

Engineered to track table additions, removals, modifications, and shifts, users
benefit from Deephaven’s highly-optimized, incremental-update model. A
chunk-oriented architecture delivers best-of-class table methods and amortizes
the cost of moving between languages.

Client-server interfaces are designed with large-scale, dense data in mind --
moving compute to the server and providing lazy updates.


BUILD, JOIN, AND PUBLISH STREAMS WITH EASE

Build streams on streams to empower applications and do analysis. Use table
operations or marry them to custom and third-party libraries. Query and combine
batch and real-time data.


HIGHLY
INTUITIVE

New data and events seamlessly arrive as simple table updates. Queries establish
an acyclic graph, with data logically flowing to downstream nodes. Simply name a
source or derived table to make it available to clients via multi-language APIs.
Use easy methods to stripe and pipeline workloads.


FAMILIAR &
POWERFUL TOOLS

Leverage gRPC and Arrow. Use Jupyter, Visual Studio, JetBrains, or [soon] R
Studio. Bring your custom or 3rd-party libraries and functions to the data for
faster and well-integrated execution. Enjoy the data interrogation experiences
of the Code Studio, with dynamic dashboards and an evolving suite of
capabilities.




EXPRESSIVE LANGUAGE


BUILT FOR DEVELOPERS, LOVED BY DATA SCIENTISTS

COMBINE YOUR STATIC AND REAL-TIME DATA SOURCES

Join and merge Kafka streams with Parquet files. Use identical operations on
batch and stream.

JOIN YOUR TIME SERIES AND AGGREGATE

STREAMLINE YOUR DATA SCIENCE

LEVERAGE GRPC AND ARROW FLIGHT LIBRARIES

from deephaven import ConsumeKafka, ParquetTools, TableTools
from deephaven2.parquet import read_table

# data-ingestion integrations (Kafka, Parquet, and many more)
table_today_live = ConsumeKafka.consume(
    {"bootstrap.servers": "kafka:9092"}, "metrics"
)
table_yesterday = ParquetTools.readTable("/data/metrics.parquet")

# merging dynamic with static is easy; the updating table will continue to update
table_merged = TableTools.merge(table_today_live, table_yesterday)

# operators can be used identically on dynamic and static tables (or merges of the two)
table_joined = table_today_live.sumBy("ProcessKey").naturalJoin(
    table_yesterday.sumBy("ProcessKey"), "ProcessKey", "YestTotal = Metric"
)




bitcoin = ConsumeKafka.consume({"bootstrap.servers": "kafka:9092"}, "bitcoin")
ethereum = ConsumeKafka.consume({"bootstrap.servers": "kafka:9092"}, "ethereum")

# time series joins update as source tables update
priceRatio = (
    bitcoin.aj(ethereum, "Timestamp", "SizeEth = Size, PriceEth = Price")
    .update("Ratio = Price / PriceEth")
    .renameColumns("SizeBtc = Size")
)

# time-bin by minute and aggregate accordingly
agg = priceRatio.update("TimeBin = upperBin(Timestamp, MINUTE)").by(
    ["TimeBin"],
    [
        AggAvg("Ratio"),
        AggMin("MinRatio = Ratio"),
        AggMax("MaxRatio = Ratio"),
        AggSum("Size", "SizeBtc"),
        AggWAvg("SizeBtc", "VwapBtc = Price"),
    ],
)




import numpy as np
from sklearn.linear_model import LinearRegression

# write a custom function
def computeBeta(value1, value2):
    stat1 = np.diff(np.array(value1), n=1).reshape(-1, 1)
    stat2 = np.diff(np.array(value2), n=1).reshape(-1, 1)
    reg = LinearRegression(fit_intercept=True)
    reg.fit(value1, value2)
    return reg.coef_[0][0]


# filter, sort and do time-series joins on source tables
iot = source.where("MeasureName = `Example`").view(
    "TimeInterval", "DeviceId", "MeasureValue"
)
iot_joined = iot.aj(iot.where("DeviceId = `Master`"), "TimeInterval", "Measure_Master")

# use the custom function within the deephaven object directly
# no client-server or copy
betas = (
    iot_joined.by("DeviceId")
    .select(
        "DeviceId",
        "Beta = (double) computeBeta.call(Measure_Master.toArray(), MeasureValue.toArray())",
    )
    .sort("DeviceId")
)



 * Java Client
 * Python Client
 * C++ Client
 * JavaScript Client

FlightSession session = newSession();
TableSpec trades = readQst("trades.qst");
TableSpec quotes = readCsv("quotes.csv");
TableSpec topTenTrades = trades
    .aj(quotes, "Timestamp", "Mid")
    .updateView("Edge=abs(Price-Mid)")
    .sortDescending("Edge")
    .head(100);
try (
    final Export export = session.export(topTenTrades);
    final FlightStream flightStream = session.getStream(export)) {
    while (flightStream.next()) {
        System.out.println(flightStream.getRoot().contentToTSVString());
    }
}




from pydeephaven import Session
from pyarrow import csv

session = Session()  # assuming DH is running locally with the default config

table1 = session.import_table(csv.read_csv("data1.csv"))
table2 = session.import_table(csv.read_csv("data2.csv"))
joined_table = table1.join(
    table2, keys=["key_col_1", "key_col_2"], columns_to_add=["data_col1"]
)

df = joined_table.snapshot().to_pandas()
print(df)
session.close()




auto client = Client::connect(server);
auto manager = client.getManager();
auto trades = manager.fetchTable("trades");
auto quotes = manager.readCsv("quotes.csv");
auto topTenTrades = trades
    .aj(quotes, "Timestamp", "Mid")
    .updateView("Edge=abs(Price-Mid)")
    .sortDescending("Edge")
    .head(100);
std::cout << topTenTrades.stream(true) << '\n';




class TableView {
  setFilter() {
    this._filters = Array.prototype.slice.apply(arguments);
    return this._table.applyFilter(this._filters);
  }
  addFilter(filter) {
    this._filters.push(filter);
    return this._table.applyFilter(this._filters);
  }
  // Use cloning when you want to create a new table
  // to apply filters without modifying the existing table.
  clone(name) {
    if (!name) {
      name = `${this._name}Clone`;
    }
    return this._table.copy().then((newTable) => new TableView(name, newTable));
  }
}





UI TOOLS


OPEN-SOURCE CODE STUDIO FOR ACCELERATED DATA EXPLORATION

Browser based interactive REPL for immediate feedback.
Industry leading data-grid, handles billions of rows with ease.
Plot large data sets with automatic downsampling.
Auto-complete column names for rapid data exploration.



BUILD WITH DEEPHAVEN


WHAT CAN YOU BUILD WITH DEEPHAVEN?

Use one of the following example apps or starter projects to get going fast

INHERIT KAFKA STREAMS AS UPDATING TABLES

A demo of two ways to consume events.

Use an interactive demo

COMBINE STREAMING FEEDS WITH PYTHON

A machine that uses Twitter and colors to solve WORDLE.

Watch the video

DRIVE UX WITH WEB-SCRAPED CONTENT

A dashboard for live sports betting lines.

See project's GitHub

BUILD APPS WITH REAL-TIME DATA

A stock monitor using Redpandas & DX-Feed.

Read blog linked to code

DO AI IN REAL TIME

Dynamic unsupervised learning to detect fraud.

Read blog linked to code

SOURCE TICKING DATA FROM CUSTOM APIS

A framework for trading via Interactive Brokers.

See project's GitHub

INTEROPERATE WITH YOUR TOOLS

A PlugIn demo for matplotlib.

Watch the video

PULL DATA FROM REST APIS

An integration with Prometheus.

Read blog linked to code

SCALE UP


ENTERPRISE DEPLOYMENT

Deephaven Enterprise has been battle-tested inside the demanding environment of
hedge funds, stock exchanges and banks. Its collection of enterprise-ready tools
and exclusive add-ons helps your team scale up quickly and benefit from the
mutualization of enhancement requests. Professional services are available if
you’d like more hands on deck.




BATTERIES INCLUDED DATA MANAGEMENT

DATA MANAGEMENT

Systems for ingesting, storing and disseminating data focus on throughput and
efficiency. Utilities exist to support cleaning, validation, and transformation.
Sophisticated control systems limit user or team access to source and derived
data, by directory and table; as well as granularly by row or column key.


SCALE ACROSS 1000S OF CORES, PBS OF DATA, AND TBS OF STREAMS

QUERY & COMPUTE

The Deephaven Enterprise platform comprises the machinery, operations, and
workflows to develop and support applications and analytics at scale --
real-time and otherwise. It is readily deployed on commoditized cloud or
physical Linux resources using modern techniques. Ingest, storage, and compute
scale independently.


CREATE AND SHARE APPLICATIONS AND INTERACTIVE DASHBOARDS QUICKLY

UI & TOOLING

Deephaven Enterprise has premiere experiences in Jupyter, Excel, R-Studio and
classic IDE’s and its REPL, but it also includes a zero-time UX for launching,
scheduling, and monitoring applications. These feed dependent enterprise apps
and empower the quick configuration and sharing of real-time dashboards.



INTEGRATIONS


INTEGRATES WITH FAMILIAR AND POWERFUL TOOLS


Sign up for our monthly newsletter to get the latest Deephaven news
Subscribe

Community Core
 * Documentation
 * Community questions
 * Open-core License
 * Pydoc client
 * Pydoc server
 * Javadoc client/server
 * Godoc client
 * C++ client
 * Barrage Docs
 * Grid Docs

Enterprise
 * Enterprise Support
 * Documentation
 * Legacy Documentation
 * Ultimate Cheat Sheet

Social
 * Blog
 * Github
 * Slack
 * Linkedin
 * Twitter
 * Youtube

Company
 * About
 * Solutions
 * Careers
 * Newsroom
 * Brand Assets
 * Contact

Copyright © 2024 Deephaven Data Labs LLC
giItT1WQy@!-/#giItT1WQy@!-/#giItT1WQy@!-/#giItT1WQy@!-/#giItT1WQy@!-/#giItT1WQy@!-/#