The document store that speaks your language.

One canonical JSON file per document. Zero-payload prefix indexes. Git-like version control for your data. If an index ever drifts, FYLO rebuilds it from the documents — files are always the source of truth.

curl -fsSL https://fylo.del.ma/install.sh | sh copy

Download Get started

✓ Filesystem-first ✓ Zero native addons ✓ One self-contained binary ✓ 13 language clients included

canonical file per document

native addons or external services

O(log n)

mmap'd prefix index lookups

language clients (shims + local-first)

Show me the code

From install to query in one minute

One binary, one JSON protocol, your language. The same engine speaks NoSQL collections and plain SQL. Pick a language, rename the collection — every sample follows.

from fylo import Fylo

with Fylo("/mnt/fylo") as db:

    db.users.create("document")
    db.users.put({"name": "Ada", "role": "admin"})
    db.users.latest("<id>")

Everything you need

Complexity traded for clarity.

Git-like version control, SQL query surfaces, field-level encryption, and durable queues — in one standalone binary with drop-in clients for 13 languages.

Storage

Documents are truth

Each document is one canonical JSON file on disk, sharded by TTID prefix. Easy to inspect, debug, back up, and rebuild from.

Indexing

Zero-payload prefix indexes

S3-style key-only index entries in an mmap'd sorted catalog. Queries narrow by binary search, then hydrate only matching documents.

Query

SQL + NoSQL APIs

Query with a JSON operation protocol — put, find, patch, join — or plain SQL over the same engine. Exact, range, prefix, and trigram strategies.

Versioning

Git-like version control

Branch, commit, diff, merge, and restore your document store. Auto-commit on writes with content-addressed, deduplicated snapshots.

Distribution

One self-contained binary

Download a single executable — no runtime, no daemon, no native addons. Install once, then use drop-in clients for 13 languages — thin shims plus local-first browser and mobile.

Security

Encryption, RLS & WORM

AES-GCM field encryption with HMAC blind indexes, app-supplied row-level security policies, and strict write-once WORM collections.

Replication

Sync hooks & local queue

onWrite / onDelete hooks in await-sync or fire-and-forget mode, plus a durable local queue with consumer groups and dead-letter files.

Architecture

No server, no protocol

Every client owns its database directly — the binary on desktop, an on-device OPFS engine in browsers and mobile. Nothing listens on a port; there is no auth surface to harden.

Interop

One protocol, many languages

A compiled executable speaks a JSON machine protocol tested against Python, Ruby, PHP, Dart, Java, C#, C++, Swift, Kotlin, and Rust.

How it works

Rebuildable, not sacred.

A collection is a directory. Index keys look like S3 object keys — field path, kind, value, doc ID — and carry no payload. If they ever drift, one rebuild reconstructs them from the documents.

One collection on disk

<root>/.collections/users/
  docs/                  ← one .json file per document
    4U/
      4UUB32VGUDW.json
  .deleted/              ← soft-deleted payloads
  index/
    manifest.json        ← format version marker
    keys.snapshot        ← sorted keys, mmap'd O(log n)
    keys.wal             ← append-only mutation log
  events/
    users.ndjson         ← append-only event journal
  locks/                 ← advisory file locks

Anatomy of an index key

name/f/alice/4UUB32VGUDW

field path index kind encoded value document TTID

Operator	Index used	Example
`$eq`	Exact match key (eq)	`role/eq.admin`
`$gte / $lte`	Sortable numeric key (n / nr)	`age/n/c03e…`
`$like 'ali%'`	Forward prefix (f)	`name/f/ali…`
`$like '%ice'`	Reversed prefix (r)	`name/r/eci…`
`$like '%lic%'`	Trigram (g3) → hydrate → verify	`name/g3/lic…`
`$contains`	Exact match on array members	`tags/eq/platform`

Questions

Frequently asked.

Nothing is lost. Documents are the source of truth and indexes are derived accelerators — the rebuild operation reconstructs every index entry by scanning the canonical document files.

Any language that can spawn a process. FYLO ships as a single binary that speaks a JSON machine protocol over stdin/stdout; drop-in shims are provided for Python, Ruby, Node/TypeScript, PHP, Go, Rust, C#, Java, and Dart, and the protocol is tested in CI against even more. For platforms that can't spawn the binary there are local-only clients that embed the engine on-device — the browser bundle, native iOS (Swift) and Android (Kotlin) clients, and a Flutter client.

Yes — Fylo Explorer is a browser UI over a real FYLO root on your disk, opened through the File System Access API. Pick the folder once and browse collections, inspect documents, and filter with SQL WHERE expressions (role = 'admin' AND age >= 30). It is read-only by default — the engine rebuilds indexes into memory, never touching the folder — with opt-in writes that go through the engine. Chromium-only, since Firefox and Safari do not implement real-folder access.

FYLO owns local storage and querying; you own how the root reaches remote storage. onWrite and onDelete sync hooks notify your storage client in await-sync or fire-and-forget mode, and the s3-client index backend can store index keys as zero-byte S3 objects.

Writes are serialized per collection with advisory file locks. There are no cross-collection atomic commits — declare related objects as their own collections and join them at query time with joinDocs.

Fields listed in a schema’s $encrypted array are stored with AES-GCM. Equality lookups use HMAC blind indexes, so queries work without decrypting — with the documented trade-off that value repetition counts are observable.

Your documents. Your filesystem. Your call.

Start with one command — no daemons, no native addons, no monolithic caches.

curl -fsSL https://fylo.del.ma/install.sh | sh

Download Star on GitHub