A pure Go implementation of Automerge, a JSON-like data structure (CRDT) that can be modified concurrently by different users and merged automatically.

Binary-compatible with the Rust automerge library -- documents created by either implementation can be loaded, modified, and saved by the other.

Tracking upstream automerge v0.8.0 (8246d0f).

Supported features:

• Document creation, loading, and saving (binary format)
• Map, list, and text CRDT types
• All scalar types: string, int, uint, float64, bool, bytes, timestamp, counter, null
• Concurrent editing with automatic conflict resolution
• Batch insertion of nested objects (v0.8.0)
• Sync protocol
• Historical queries (point-in-time reads)
• Cursors and marks

go get github.com/develerltd/go-automerge@v0.8.0

Requires Go 1.24 or later.

package main

import (
    "fmt"

    "github.com/develerltd/go-automerge/automerge"
)

func main() {
    // Create a new document
    doc := automerge.New()

    // Put values into the root map
    doc.Put(automerge.Root, automerge.MapProp("title"), automerge.NewStr("Hello"))
    doc.Put(automerge.Root, automerge.MapProp("count"), automerge.NewInt(42))
    doc.Commit("initial", 0)

    // Save to bytes (binary format, compatible with Rust automerge)
    data := doc.Save()

    // Load from bytes
    doc2, err := automerge.Load(data)
    if err != nil {
        panic(err)
    }

    val, _, err := doc2.Get(automerge.Root, automerge.MapProp("title"))
    if err != nil {
        panic(err)
    }
    fmt.Println(val.Str()) // "Hello"
}

Cross-implementation tests verify binary compatibility with the Rust automerge library:

• Loading Rust-generated fixtures in Go (10 fixture types covering all features)
• Round-trip: Load -> Save -> Load produces identical documents
• Double round-trip: Save -> Load -> Save produces identical bytes
• Go-created documents are loadable by the Rust CLI

CI runs these tests weekly against the pinned upstream commit to detect drift.

Benchmarks run on an Intel i9-13900HX (linux/amd64). Go uses per-object B-trees for the mutable OpSet, matching the Rust architecture. Rust benchmarks use criterion; Go benchmarks use testing.B with -count=3.

go test ./automerge/ -bench=. -benchmem

Go is 2-15x faster than Rust for all mutation benchmarks.

Save is 1-4x slower for repeated-put (materializing all ops from trees), but comparable or faster for increasing-put at scale.

Load is 2-5x slower for repeated-put (many B-tree inserts into one object), but 2-3x faster for increasing-put at scale (many small per-object trees).

BatchCreateObject and InitFromHydrate use BFS traversal with bulk OpSet insertion. For a structure with 50 maps each containing 3 scalars and a 2-element list (~300 ops total):

~2.4x faster, ~3.9x fewer allocations.

See automerge/bench_test.go for the full benchmark suite.

This is a pure Go port of automerge/automerge (Rust). Currently tracking version 0.8.0. No CGo required.

MIT