Cloud Parts

TileDB

An embeddable C++ storage engine and open format for dense and sparse multi-dimensional arrays, on local disk or cloud object storage.

What it is
File formats (array formats)
Type
Open source
Made by
TileDB, Inc. (trading as Tile.ai since September 2026)
License
MIT for the engine (TileDB Embedded), its language APIs and the published format specification; the company’s hosted platform and its new Tile.ai product are commercial
Facts checked
6 October 2026
Website Source code

What it is

TileDB stores data as multi-dimensional arrays. A dense array fills every cell of a grid, like an image or a climate model’s lattice. A sparse array stores only the cells that exist, keyed by their coordinates, like genomic variants by sample and position or the points of a LiDAR scan. Dataframes and key-value data are stored as sparse arrays too; TileDB 2.0 (2020) added string dimensions and dimensions of different types for that. Cells are grouped into fixed-size tiles, each attribute is stored in its own files and run through a chain of compression, encryption and checksum filters, so a read fetches only the tiles and attributes a slice touches.

Every write creates an immutable fragment: a folder of files whose name carries the time range it covers, in milliseconds. Old files are never edited, which turns random writes into sequential ones and suits object stores such as S3, Google Cloud Storage and Azure Blob Storage. Readers merge fragments, with the newest value winning, and can open the array as of an earlier timestamp. As fragments pile up, consolidation merges them and vacuuming removes the ones it replaced. The engine is a C++ library with C, C++, Python, R, Java, Go and C# APIs, and domain packages build on it: TileDB-VCF for genomic variants, TileDB-SOMA for single-cell data and TileDB-Vector-Search.

TileDB, Inc. built a commercial platform around the engine. In September 2026 the company renamed itself Tile.ai and pivoted to a governed data layer for AI agents, then in private preview. Its founder wrote that the open-source engine “will keep going, under the TileDB name, exactly as it is.”

Why teams pick it

  • One engine for dense and sparse data of any dimensionality, from images and genomes to dataframes
  • Built for object storage: immutable fragments, parallel I/O and a multi-threaded C++ core
  • Versioning built in: open an array as of any earlier timestamp
  • MIT licence and a published, versioned format specification

Watch out for

  • A library you embed, not a database server; sharing and governance were the job of the company’s commercial platform
  • Many small writes mean many fragments, and reads slow down until you consolidate and vacuum
  • Its own format: other tools need a TileDB library or integration to read the data
  • The company’s focus moved to Tile.ai in 2026; the engine is still maintained, but check release activity before betting on it

How it fits with other technologies

Create, write, slice and time-travel a dense array · python

import numpy as np
import tiledb

uri = "s3://my-bucket/grid"   # or a local path
dom = tiledb.Domain(
    tiledb.Dim(name="rows", domain=(1, 4), tile=4, dtype=np.int32),
    tiledb.Dim(name="cols", domain=(1, 4), tile=4, dtype=np.int32),
)
schema = tiledb.ArraySchema(domain=dom, sparse=False,
                            attrs=[tiledb.Attr(name="a", dtype=np.int32)])
tiledb.DenseArray.create(uri, schema)

with tiledb.open(uri, mode="w") as A:       # one write = one fragment
    A[:] = np.arange(1, 17).reshape(4, 4)

with tiledb.open(uri) as A:
    print(A[1:3, 2:5]["a"])                 # rows 1-2, cols 2-4 only

with tiledb.open(uri, timestamp=ts_ms) as A:  # the array as it was at ts_ms
    print(A[:]["a"])

See it in a real stack

No architecture uses TileDB yet. Drop it into the playground and wire it up yourself.Open playground →
Where it came from2016–2026

TileDB began as research at Intel Labs and MIT. Scientific data such as genomes, images and sensor grids are naturally arrays, but the standard array library, HDF5, handled sparse arrays poorly and was slow at small, scattered in-place writes. A 2016 paper by Stavros Papadopoulos, Kushal Datta, Samuel Madden and Timothy Mattson described a storage manager built for both dense and sparse arrays, with writes grouped into fragments. It reported HDF5-level speed on dense arrays, much faster random writes, and big wins over the SciDB array database; the Broad Institute was already using it for terabytes of genomic data.

TileDB, Inc. spun out of MIT and Intel in 2017 with a $1 million round co-led by Nexus and Intel Capital, and released TileDB 1.0 that October, a substantial rewrite of the earlier Intel code. A $4 million round followed in January 2019 and a $15 million series A, led by Two Bear Capital, in 2020. TileDB 2.0 (April 2020) brought string and mixed-type dimensions, which let dataframes live in sparse arrays, and native Google Cloud Storage and Azure Blob Storage support. The company sold a hosted platform for genomics, single-cell, imaging and geospatial work.

On September 16, 2026 the company announced it was becoming Tile.ai, a product that leaves data where it lives and exposes it to AI agents under each user’s identity. Papadopoulos stepped back from CEO to focus on product, George Llado became CEO, and Amgen and Two Bear Capital backed the change. The open-source engine keeps the TileDB name.

Why it’s built this way

Everything is an array, dense or sparse
Each scientific field had built its own incompatible tools, and HDF5 captured sparse data badly. The bet was that one engine handling both kinds of array could replace many silos.
Immutable, timestamped fragments
Writing each batch as a new fragment turns random writes into sequential ones and avoids slow small in-place updates. The timestamps also give versioning and time travel; consolidation merges fragments later, in the background.
Storage engine first, compute pluggable
Papadopoulos described it in 2020 as a database focused on “universal storage and data management rather than the compute layer, which we have instead made ‘pluggable’”, so Spark, Dask, GDAL or Python could sit on top.
An open, published format
The founder later called it a choice for an open format, “published and unencumbered, rather than a proprietary black box”; the spec lives in the repository next to the code.

Timeline

  1. 2016

    PVLDB paper on the TileDB array storage manager, from Intel Labs and MIT

  2. 2017

    TileDB, Inc. spins out; TileDB 1.0 is released in October

  3. 2019

    $4 million round led by Nexus

  4. 2020

    TileDB 2.0 adds string and mixed-type dimensions; $15 million series A

  5. 2026

    The company renames itself Tile.ai; the MIT engine keeps the TileDB name

Sources11 · facts checked 6 October 2026

Improve this page on GitHub