Managed LanceDB, durable on S3.

Walleye is a LanceDB server with a write-ahead log on S3 and a thin RAM/NVMe cache. We run it as a managed instance; you connect with the stock LanceDB Python and JavaScript SDKs.

Start free Read the docs

Connect

The LanceDB clients you already use.

Create an instance, copy its URL and token, and point the stock LanceDB Python or JavaScript client at it. There is no Walleye SDK to learn and no proxy in front of your data: the client speaks the LanceDB remote protocol straight to the instance.

Python

pip install lancedb 
import lancedb

db = lancedb.connect(
    "https://<instance>.fly.dev",
    api_key="<instance token>",
)

table = db.create_table("clicks", data=[
    {"id": 1, "city": "ams", "value": 2.0},
    {"id": 2, "city": "ams", "value": 3.0},
    {"id": 3, "city": "ber", "value": 7.0},
])

print(table.count_rows())
print(table.search().where("city = 'ams'").to_list())

JavaScript

npm install @lancedb/lancedb 
import * as lancedb from "@lancedb/lancedb";

const db = await lancedb.connect({
  uri: "https://<instance>.fly.dev",
  apiKey: "<instance token>",
});

const table = await db.createTable("clicks", [
  { id: 1, city: "ams", value: 2.0 },
  { id: 2, city: "ams", value: 3.0 },
  { id: 3, city: "ber", value: 7.0 },
]);

console.log(await table.countRows());
console.log(await table.query().where("city = 'ams'").toArray());

Every write is committed to the instance's write-ahead log in S3 before the client gets its acknowledgement. Rotate the token from the dashboard to revoke every client at once.

How it works

A write-ahead log on S3.
A cache on NVMe.

  1. Every write lands in S3 first.

    A write is acknowledged only once it is durable in the instance's own S3 bucket. A Ramp instance commits each write with an S3 conditional put; a Launch instance commits to a log replicated across three nodes and archives it to S3 within a second.

  2. Reads come from RAM and NVMe.

    Hot fragments and indexes live in a thin cache on the node. Tables can be larger than the cache; colder data is read from S3 on demand. The cache is disposable and is rebuilt from S3 whenever a node is replaced, so losing a node loses no acknowledged write.

  3. One node or three.

    Ramp is a single node. Launch is three nodes behind the same URL, each serving the LanceDB API, with a write quorum of two, so a node replacement never interrupts your writers. Move from Ramp to Launch with a stop, a resize and a start.

Read about instances

Shapes and cache tiers

Pick a shape. Pick a cache. Resize later.

The shape decides how many nodes commit a write and what CPU they run on: Ramp on shared CPUs, Launch on performance CPUs. The cache tier decides how much memory and disk each node has. Both are chosen when you create an instance and can be changed while it is stopped.

Ramp

1 node · shared CPU
Durability
Every write is an S3 conditional put before it is acknowledged.
Use it for
Development, single-writer workloads, and anything that tolerates a short pause while the node is replaced.

Launch

3 nodes · performance CPU
Durability
Each node runs the replicated write-ahead log. A write commits at a quorum of two and is archived to S3 within a second.
Use it for
Production workloads that must keep serving while a node is replaced. Every node answers the API behind one URL.
Shape and cache tier, per node
ShapeCacheMachineDisk
rampsmallshared-cpu-1x, 2 GiB8 GB
rampmediumshared-cpu-2x, 4 GiB16 GB
ramplargeshared-cpu-4x, 8 GiB32 GB
rampxlargeshared-cpu-8x, 16 GiB64 GB
launchsmallperformance-2x, 8 GiB32 GB
launchmediumperformance-4x, 16 GiB64 GB
launchlargeperformance-8x, 32 GiB128 GB
launchxlargeperformance-16x, 64 GiB256 GB

A tier is one Machine and one disk: the memory is the node's, and the disk is the NVMe volume it mounts, at exactly that size, four times the memory. A Ramp node has 2 GiB per shared vCPU; a Launch node has 4 GiB per performance vCPU and is one size up. The cache is the working set, not a storage limit. Tables can be larger than the disk; colder data is read from S3 on demand.

Compare shapes and cache tiers

Pricing

One hourly rate per instance.

No plans, no organization fee and no seat charges. You pay for the instances you run, at the rate of their shape and cache tier, billed per second. Ramp small suspends when idle and bills nothing while asleep. Storage and egress are added on top; a stopped instance costs storage only.

Instance rates by shape and cache tier
ShapeCacheMachinePer hourAlways on, per month
ramp small shared-cpu-1x, 2 GiB $0.054 $39from $5/month, billed per second while running
ramp medium shared-cpu-2x, 4 GiB $0.108 $79
ramp large shared-cpu-4x, 8 GiB $0.204 $149
ramp xlarge shared-cpu-8x, 16 GiB $0.410 $299
launch small 3 × performance-2x, 8 GiB $1.095 $799
launch medium 3 × performance-4x, 16 GiB $2.053 $1,499
launch large 3 × performance-8x, 32 GiB $4.108 $2,999
launch xlarge 3 × performance-16x, 64 GiB $8.218 $5,999

A month is 730 hours. Launch rates cover all three nodes. Ramp small is serverless: Fly suspends it after a few idle minutes and wakes it on the next request, so it costs $5 in any month it runs less than 93 hours and the hourly rate above it.

Storage
$0.05 / GB-month
10 GB included per ramp instance, 100 GB per launch instance
Egress
$0.05 / GB
100 GB included per organization each month
Free trialNo card required

$0

One ramp small instance until it has used $5 of compute. It ends on that figure, not on a date, and an idle instance costs nothing.

1 instance · ramp small · Email support

Start free
Add a cardAny shape, any tier, any number

$0/ month

There is no subscription fee and no seat charge. You pay the instance rates above, plus storage and egress over the included capacity.

As many instances as your team needs, in any shape and cache tier, with unlimited members in any role. Email support for everyone.

Usage is collected in arrears at monthly renewal.

Get started

Your tables. Your bucket.

Create your first instance.

Start free → Read the docs