Stop explaining your project to every new chat.

Only someone holding your message. Your text is locked in this page, in your browser, with a key that is made here. We store the locked copy and never the key. Treat the message like a password: anyone you give it to can read your cache and write to it.

On an immutable ledger, using blockchain technology. Everything is encrypted in your browser before it leaves, and only the encrypted copy is written to the ledger. It does not live on any one server, so your notes are safe from server downtime: if ours went down tomorrow, your cache would still be there and still yours to open.

Throw away the message and it is as good as gone: without the key nobody can ever read it, including us. The encrypted copy itself stays on the ledger, because a ledger that could lose things could lose yours. As with any notes tool, leave passwords and card numbers out.

In the message as written, yes, for a moment. The key rides in the address so the chat gets plain text back; the server unlocks that one request and keeps neither the key nor the text. If you would rather the key never left your chat, use private mode below: the server hands over the locked copy only and the chat unlocks it itself.

Reading works in any chat that can open a web address. Saving back needs a chat that can run a few lines of code. It was built and tested with Claude.

Then the cache cannot be opened or updated by anyone. Keep the message in your password manager or your notes. It is shown once.

300 KB a version, which is around 50,000 words. Every bury is a new version and the older ones stay readable.

The line is cache:<name>#<key>.<write>. The name finds the newest version, the key unlocks it, the write token lets a chat bury a new one. The quick address, which the message uses:

https://cache.gekker.lol/api/cache/<name>?key=<key>&format=text

Private mode in Python: the reader serves the locked copy and the chat unlocks it.

import base64, json, urllib.request
from cryptography.hazmat.primitives.ciphers.aead import AESGCM   # pip install cryptography

def b64u(s): return base64.urlsafe_b64decode(s + '=' * (-len(s) % 4))
def unb64u(b): return base64.urlsafe_b64encode(b).decode().rstrip('=')

name, key, write = 'rachel-vulpine', '', ''
j = json.load(urllib.request.urlopen(f'https://cache.gekker.lol/api/cache/{name}'))
raw = b64u(j['ciphertext']); text = AESGCM(b64u(key)).decrypt(raw[:12], raw[12:], None).decode()
print(text)                                            # the document, version j['version']

# to bury the next version:
import os
iv = os.urandom(12); ct = AESGCM(b64u(key)).encrypt(iv, new_text.encode(), None)
req = urllib.request.Request(f'https://cache.gekker.lol/api/cache', method='POST',
    data=json.dumps({'name': name, 'ciphertext': unb64u(iv + ct), 'write': write}).encode(),
    headers={'Content-Type': 'application/json'})
print(json.load(urllib.request.urlopen(req)))          # {ok, version, outpoint, txid}: say "saved" only after this

The same in JavaScript, in a browser or Node 18 and later:

const b64u = (s) => Uint8Array.from(atob(s.replace(/-/g,'+').replace(/_/g,'/')), c => c.charCodeAt(0))
const unb64u = (b) => btoa(String.fromCharCode(...new Uint8Array(b))).replace(/\+/g,'-').replace(/\//g,'_').replace(/=+$/,'')
const k = await crypto.subtle.importKey('raw', b64u(key), 'AES-GCM', false, ['encrypt','decrypt'])
const j = await (await fetch(`https://cache.gekker.lol/api/cache/${name}`)).json()
const raw = b64u(j.ciphertext)
const text = new TextDecoder().decode(await crypto.subtle.decrypt({ name:'AES-GCM', iv: raw.slice(0,12) }, k, raw.slice(12)))
// bury: iv = crypto.getRandomValues(new Uint8Array(12)); ct = await crypto.subtle.encrypt({name:'AES-GCM', iv}, k, new TextEncoder().encode(newText))
// POST /api/cache { name, ciphertext: unb64u(concat(iv, ct)), write }

Every bury is a new inscription and the name always finds the newest. A write token is shown once. Say "saved" only when the transaction id comes back.