Pixeltable and Fly.io

Fly.io hosts any app: fly launch / fly deploy builds a Machine from fly.toml and a Dockerfile, in regions you pick, with Anycast HTTP. Pixeltable is the data, orchestration, and serving layer in one Python file: typed media tables, computed columns, embedding indexes, and FastAPIRouter. Fly.io does not own that schema. Pixeltable Cloud is Limited Beta, not GA. They are complementary: Fly.io can host the Pixeltable process.

pip install 'pixeltable[serve]'
See how it works

Edge Machines vs the application schema

SidePixeltableFly.io
At a glance
  • Database, orchestration, and serving in one Python file
  • Insert a row; computed columns, indexes, and HTTP follow
  • Open source; Pixeltable Cloud is Limited Beta, not GA
  • Not a global Machine fabric for arbitrary frameworks
  • fly launch / fly deploy: Dockerfile + fly.toml Machines, Anycast IPv6, shared IPv4
  • Compute billed per second while a Machine runs; stopped Machines pay $0.15/GB-month of rootfs. Volumes $0.15/GB-month
  • Cheapest always-on size: shared-cpu-1x with 256 MB is $2.19 per 30 days in iad/ewr; extra RAM $6/GB-month. Egress NA/EU $0.02/GB
  • Hosts any app close to users; you still add storage, transforms, and an index unless the schema owns them

Where each fits

Fly.io wins regional Machines, autostop/autostart, and per-second compute with no monthly platform fee. Pixeltable wins insert-triggered multimodal pipelines and HTTP declared beside the tables. Last reviewed: Oct 2026. Sources: docs.fly.io (fly.toml, deploy, pricing), docs.pixeltable.com/howto/deployment/serving.

FeaturePixeltableFly.io
What it is
Application schema: store, transform, index, serve
Regional Machines that run your container
Deploy any language or framework
Python Pixeltable apps; not a general PaaS
Any OCI image, many regions, autostop/autostart
Multimodal tables and incremental compute
Typed media columns; dependents of a changed row recompute
You write that layer in the process the Machine runs
Embedding index
EmbeddingIndex declared on the source table
A Machine or volume-backed store you add
HTTP serving
FastAPIRouter in the same file as the tables
Fly Proxy: [http_service], force_https, concurrency, autostop
Pricing shape
Open source locally; Cloud Community is free in Limited Beta
No Machines platform fee; pay per second of CPU/RAM plus volume and egress

One file vs fly.toml

Pixeltable: tables, chunking, EmbeddingIndex, FastAPIRouter. Fly.io: Machines that run whatever you built. Last reviewed: Oct 2026. Fly.io: https://docs.fly.io/reference/configuration and https://docs.fly.io/launch/deploy

Pixeltable

import pixeltable as pxt
from pixeltable.functions.document import document_splitter
from pixeltable.functions.huggingface import sentence_transformer
from pixeltable.serving import FastAPIRouter
TableModel = pxt.model_base()
embed = sentence_transformer.using(
model_id='sentence-transformers/all-MiniLM-L6-v2'
)
class Docs(TableModel, name='docs'):
document: pxt.Document
title: pxt.String
class Chunks(
TableModel,
name='chunks',
base=Docs,
iterator=document_splitter(
document=Docs.document, separators='sentence,token_limit', limit=512
),
):
__indexes__ = [pxt.EmbeddingIndex(text, string_embed=embed)]
@pxt.query
def search_docs(query: str, limit: int = 5):
sim = Chunks.text.similarity(string=query)
return (
Chunks.order_by(sim, asc=False)
.limit(limit)
.select(Chunks.text, Chunks.title, sim)
)
api = FastAPIRouter(name='docs')
api.add_insert_route(Docs, path='/docs', inputs=[Docs.document, Docs.title])
api.add_query_route(path='/search', query=search_docs)
# pxt schema update app.py docs && pxt service update app.py docs
# Or mount the router on FastAPI and host that process on Fly.io.

Fly.io

# fly.toml — https://docs.fly.io/reference/configuration
app = "docs-api"
primary_region = "iad"
[http_service]
internal_port = 8080
force_https = true
auto_stop_machines = "stop"
auto_start_machines = true
min_machines_running = 0
[[vm]]
size = "shared-cpu-1x"
memory = "256mb"
# fly launch && fly deploy
# The Machine runs your Dockerfile. Object storage, the embed
# job, and the vector DB are still services you wire yourself.
# Fly.io is not the multimodal table.

When each belongs

Use Pixeltable when

  • The app is media, models, and retrieval

    One Python file for tables, computed columns, indexes, and HTTP. A coding agent writes it; you review one diff. pip install pixeltable. Cloud is Limited Beta.

  • You were about to glue FastAPI to object storage, a worker, and a vector DB on Fly

    Fly.io will host that stack close to users. Pixeltable replaces the glue for this job, whether you run it locally or as the process a Machine deploys.

Use Fly.io when

  • You need Machines in many regions, not only a Pixeltable schema

    Any container, Anycast HTTP, autostop/autostart. Fly.io is the host. Docs: https://docs.fly.io/launch/deploy

  • You want per-second Machines with no platform seat fee

    shared-cpu-1x / 256 MB is $2.19 per 30 days in iad/ewr. Stopped Machines pay rootfs only. https://fly.io/docs/about/pricing/

Making the right choice

  • Complementary, not a swap

    • Fly.io hosts the Machine. Pixeltable is the schema inside it (or on Pixeltable Cloud, Limited Beta).
    • A typical glue stack on Fly is still object storage + a worker Machine + a vector DB + FastAPI. The host does not collapse those boxes.
    • To run together: mount FastAPIRouter on uvicorn (docs.pixeltable.com/howto/deployment/serving) and point [http_service] at that port, or keep Cloud as the catalog and Fly as another app.
    • Same aisle as Railway, Render, Modal, and Vercel: serving and deploy, not the multimodal table.

Frequently asked questions

Declare the app file. Host it on Fly.io if you want.

Tables, indexes, and routes in app.py. Apply with pxt schema update and pxt service update. Fly.io still hosts whatever process you ship. Cloud is Limited Beta.

pip install 'pixeltable[serve]'
See how it worksGet expert guidance