---
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
# npm
npx bog-new

# yarn
yarn dlx bog-new

# pnpm
pnpm dlx bog-new

# bun
bunx bog-new

# deno
deno x -A npm:bog-new
```
This creates `./bog` from the public BogKit workspace pinned at [`80fd3c9`](https://github.com/flowercomputers/bogkit/commit/80fd3c9a023e877fff2e5d127accca386d437af0), verifies the download, and runs `cargo run -p timeseries`. Requires Node.js 20+ and a current stable Rust toolchain.

## 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">

- **`bog-new: bog already exists`** — Choose a new destination with `--dir my-bog`; the launcher never overwrites a directory.
- **`bog-new: fetch failed`** — Restore network or DNS access, then rerun the Install command.
- **`downloaded archive checksum mismatch`** — Do not use the partial project; rerun the Install command to fetch and verify a fresh archive.
- **`cargo: command not found`** — Install a current stable Rust toolchain, then rerun `cargo run -p timeseries`.
- **``package(s) `timeseries` not found in workspace``** — Run the command from the generated `bog` 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/))

## 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](https://github.com/flowercomputers/bogkit) is public today, with [Fold](https://github.com/flowercomputers/bogkit/tree/main/fold), [ESE](https://github.com/flowercomputers/bogkit/tree/main/ese), [ANNy](https://github.com/flowercomputers/bogkit/tree/main/anny), and [runnable examples](https://github.com/flowercomputers/bogkit/tree/main/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](https://enzyme.garden/), the embedding runtime delivered a measured ~6x end-to-end speedup, trending toward 12x with batching. At [Subvert](https://subvert.fm/), 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](https://github.com/flowercomputers/bogkit) is public today. Bog's core will be free, source-available software, with its license settled before public release.