---
title: "Bog — compiled data runtime"
description: "A promptable quickstart for BogKit and Bog's compiled data model."
canonical: "https://bog.new/"
---

# Bog is a compiled data runtime: declare your schema and access patterns, get back a purpose-built database artifact that fuses relational, semantic, and graph access.

The full Bog language and runtime are prerelease. Its public components are usable today in [BogKit](https://github.com/flowercomputers/bogkit): Fold, ESE, ANNy, and runnable examples.

## Install

```console
git clone https://github.com/flowercomputers/bogkit.git
cd bogkit
cargo run -p timeseries
```

## See an incremental view update

The `timeseries` example inserts six weather readings into Fold-backed total, hourly, daily-rain, and raw-reading views. It then retracts one rainy reading; Fold updates each affected materialized view instead of rebuilding it.

Expected output:

```text
after initial ingest
total readings: 6
hourly weather:
  hour 0: 3 samples, avg temp 18.5 c, avg wind 7.0 mph, rain 1.2 mm
  hour 1: 2 samples, avg temp 17.4 c, avg wind 10.8 mph, rain 0.4 mm
  hour 24: 1 samples, avg temp 20.1 c, avg wind 4.1 mph, rain 0.7 mm
daily rain:
  day 0: 1.6 mm
  day 1: 0.7 mm
raw readings still queryable: 6

after retracting one rainy reading
total readings: 5
hourly weather:
  hour 0: 2 samples, avg temp 18.6 c, avg wind 6.0 mph, rain 0.0 mm
  hour 1: 2 samples, avg temp 17.4 c, avg wind 10.8 mph, rain 0.4 mm
  hour 24: 1 samples, avg temp 20.1 c, avg wind 4.1 mph, rain 0.7 mm
daily rain:
  day 0: 0.4 mm
  day 1: 0.7 mm
raw readings still queryable: 5
```

## Decide

<div class="decision-boundary">

**Use Bog if:**

- one query needs to fuse semantic + relational + graph
- you're stitching Postgres + vector store + reranker + glue
- you need incremental/streaming views
- you're building agent memory
- you're on edge/CPU-only hardware

**Don't use Bog if:**

- you need ad hoc runtime queries against an arbitrary surface
- you need multi-writer/multi-node today
- a well-tuned single-modality Postgres is already comfortable

</div>

## Troubleshooting

<div class="troubleshooting">

- **`cargo: command not found`** — Install a current stable Rust toolchain, then rerun the same command.
- **Git reports that `bogkit` already exists** — Choose a fresh empty directory before restarting the exact path.
- **Git reports `Could not resolve host: github.com` while cloning** — Restore network or DNS access, then rerun the first Install command from a fresh empty directory.
- **``package(s) `timeseries` not found in workspace``** — Verify that the current directory is the cloned `bogkit` workspace root.

</div>

## Next 3 tasks

1. swap in your own schema and recompile
2. add hybrid BM25 + semantic search with ESE + ANNy
3. stream live data through a Fold sliding-window view (see [flowerhose](https://flowerhose.fly.dev/))

## Links

- [Docs](https://docs.flowercomputer.com/)
- [BogKit](https://github.com/flowercomputers/bogkit)
- [flowerhose](https://flowerhose.fly.dev/)
- [Flower Computer](https://www.flowercomputer.com/)
- [X](https://x.com/flowercomputers)

## FAQ

### What is Bog?

Bog is a compiled database system. Traditional databases are interpreters: queries are parsed, planned, and executed against a generic runtime at query time. Bog front-loads that work so schema and access patterns compile into fused indices, pre-planned queries, and memory layouts for a known workload, giving predictable performance with no planner surprises and no SQL injection surface.

### What can I use today?

BogKit is public today, with Fold, ESE, ANNy, and runnable examples. Those examples cover an incremental timeseries store, a live chat backend, and hybrid BM25 + semantic search. The full Bog language and runtime are prerelease.

### Do I need to replace my database?

No. The default first deployment is a sidecar: keep Postgres or Supabase, and point Bog at one painful search-, retrieval-, or memory-shaped workload.

### What's the catch?

Queries must be declared before runtime: you cannot run a wholly new query that the artifact was not compiled for. That asks for more intentionality up front in exchange for speed and predictability.

### Can it handle streaming/real-time data?

Yes. The engine descends from incremental view maintenance and differential dataflow, so changes flow through a compiled operator graph and declared queries stay current. [flowerhose](https://flowerhose.fly.dev/) ingests the live Bluesky firehose from one small process.

### Why not Postgres + pgvector + glue?

That stack is fine for single-modality workloads. When one user-facing query must fuse semantic + relational + graph in one shot, it becomes two systems, a cross-system join, a reranker, and brittle orchestration. Bog compiles those modes into one access path.

### Is it fast?

At Enzyme, the embedding runtime delivered a measured ~6x end-to-end speedup, trending toward 12x with batching. At Subvert, multi-modal natural-language catalog search dropped from seconds to milliseconds. See the measured [static embedding throughput](https://www.flowercomputer.com/news/fast-static-embedding/).

### Is it open source?

BogKit is public today. Bog's core will be free, source-available software, with its license settled before public release.