Start in 15 minutes

This page gets two devices in sync. The first part needs no Google account: two databases sync through a shared folder, which is how you develop and test. The second part switches to Google Drive.

1. Try it without Google

CLI

cargo install bothy-cli

# Two local databases ("a" and "b") that sync through a folder.
bothy --db a init --remote path:/tmp/bothy-shared
bothy --db b join --remote path:/tmp/bothy-shared

bothy --db a put notes n1 '{"title": "Hello", "done": false}'
bothy --db a sync
bothy --db b sync
bothy --db b get notes n1        # {"done":false,"title":"Hello"}

Python

pip install bothy

import bothy

remote = bothy.FolderRemote("/tmp/bothy-shared")
a = bothy.Database.open("a.db", app_id="com.example.notes", remote=remote)
b = bothy.Database.open("b.db", app_id="com.example.notes", remote=remote)
a.init_or_join()
b.init_or_join()

a.collection("notes").put("n1", {"title": "Hello", "done": False})
a.sync()
b.sync()
print(b.collection("notes").get("n1"))   # {'done': False, 'title': 'Hello'}

Flutter

# pubspec.yaml; building needs a Rust toolchain (https://rustup.rs)
dependencies:
  bothy: ^0.4.0

import 'package:bothy/bothy.dart';

await Bothy.initialize();
final remote = BothyRemoteSpec.path('${dir.path}/shared');
final a = await Bothy.open(path: '${dir.path}/a.db', appId: 'com.example.notes', remote: remote);
final b = await Bothy.open(path: '${dir.path}/b.db', appId: 'com.example.notes', remote: remote);
await a.initOrJoin();
await b.initOrJoin();

await a.collection('notes').put('n1', {'title': 'Hello', 'done': false});
await a.sync();
await b.sync();
print(await b.collection('notes').get('n1'));

Rust

[dependencies]
bothy = "0.4"
serde_json = "1"
tokio = { version = "1", features = ["macros", "rt-multi-thread"] }

use std::sync::Arc;
use bothy::{Config, Database, remote::FolderRemote};
use serde_json::json;

#[tokio::main]
async fn main() -> bothy::Result<()> {
    let remote = Arc::new(FolderRemote::new("/tmp/bothy-shared")?);
    let a = Database::open(Config::new("a.db", "com.example.notes"), remote.clone()).await?;
    let b = Database::open(Config::new("b.db", "com.example.notes"), remote).await?;
    a.init_or_join().await?;
    b.init_or_join().await?;

    a.collection("notes")?.put("n1", json!({"title": "Hello", "done": false})).await?;
    a.sync().await?;
    b.sync().await?;
    println!("{:?}", b.collection("notes")?.get("n1").await?);
    Ok(())
}

Edit the same note on both sides before syncing, one field each, and both edits survive. Edit the same field and the later one wins; the other is kept in the conflict log.

2. Sync through Google Drive

Note

Bothy signs in with an OAuth client of your own Google Cloud project. Creating one takes about ten minutes, once: see Set up Google sign-in. All devices of a database must use clients of the same project.

1. Create the Google Cloud project and download a Desktop app client (guide).

2. Sign in and create an encrypted database on the first computer:

   bothy auth setup --client ~/Downloads/client_secret_desktop.json
   bothy auth login                     # opens the browser
   bothy init --encrypt --remember      # asks for a password twice
   bothy put notes n1 '{"title": "From my laptop"}'
   bothy sync

3. On the second computer, with the same client file:

   bothy auth setup --client client_secret_desktop.json
   bothy auth login
   bothy join --remember                # the same password
   bothy get notes n1

4. Keep both in sync in the background, with a direct channel while both are online:

   bothy sync --watch --p2p

Next: how sync works, or a guide for Flutter, Python or robots.