Programmer demo art inviting feedback, not clicks.
Nothing works, this isn't a product landing page but expedited portotypin.
What you see is all you get; technical notes conclude.
Report interest for earliest access.

rdv

the anonymous mesh rendezvous

for REF/ACTORed apps & tokens

connecting all

The social mesh network of apps for activists, neighbors, strangers and loved ones.
Frictionless web where everything can be shared in place, and interactions can start anywhere with anyone.
Create anonymous rendezvous in one click, ready to share & meet; fill them as you wish.
Mobile web and web, privacy-focused cloud to connect everything and everyone together.
Let's escape technocratic cyberstalking. True privacy controls because we need control back!
Don't even log in. You can sync in our cloud later.

linking politely

Follow a QR code or link like rdv.to//pierre//chat,
optionally identified like rdv.to//pierre#2jPkCgFVrvkjFa8KSBpG.-SRzrJTsXcOJuN0ad8uKlgU,
or anonymous like rdv.to//a/2jPkCgFVrvkjFa8KSBpG.-SRzrJTsXcOJuN0ad8uKlgU:
you have securely joined.

Choose whether to keep an identifier when carried by a link,
provide a profile reflecting facets of your choosing, sometimes upon request;
interact in a shared digital space built by its creators.

polyvalent

You can join and start interactive spaces for family & friends, bakeries & seminars;
you can even prepare for the inevitable by sharing prepared spaces in your persisting absence;
dispose securely when done or archive forever!

Mix & match documents & apps from all over,
leverage integrated messaging to create real connections,
craft in advance or collaborate in real-time.

You manage your identifiers, their profiles, & your apps; we manage the wiring.
Embrace new identities at will, share only who and what you want, with who you want.

Each identifier can be new!
Skipping last names at a festival, a QR code scan later you can go digital.
Or bring ad-hoc business facades at a conference. No setup or login needed.

made together

Each space brings a unique experience straight from and to your contact(s), outside our control.
Everyone comes as who they want, brings what they want their way, outside our control.

You can integrate with our platform with plain old web development techniques. We provide official libraries. We support and embrace the open web!
And to spice it up, we have a whole new open source runtime, blorg, that runs our cloud.
It's designed to facilitate rapid identity-state-view interactive development and powers everything we do!

anonymous

Unless mentioned by name, identifiers are always anonymous but referable,
like H0Kew7NkgmhDx_o61_NcO-hQpizaK4NzUxFi7SPVLsB0.
We route your requests & messages through remote anonymizing connections securely.

safe everywhere

Our platform builds on end-to-end encryption and we only store what we need.
The only account recovery method involves multiple master sub-keys you copy or we send to multiple E-mails.
A chosen number of them need to rendezvous to recover the account.
This uses a crypto technique known as Shamir's Secret Sharing.

Data and metadata are only used to operate the service.
Nothing is shared with anyone without your explicit consent, as long as we can help it.
Even we cannot open end-to-end encrypted data.

Operating federally from Canada on infrastructure in Switzerland,
we have not had to share anything without consent as of [not started].

ethical core for a distributed world

We only earn real customer money, at any cost.
Commoditizing the distributed web is not enough,
it needs public utility for smoother yet fairer authentication, consented tracking, pseudonymous micro-payments, and reputation.

We're not into bullshit, there's a cost attached to this. We're paying it.
What's free is free and we'll always connect everybody for free, but we also run a platform with money.
We take refills of $20 or more and a 5% commission.
Our premium tier of $.10/day bundles:


project vision

  1. Self-identify or hide contextually
  2. Every thing can be a prototype for the next
  3. Save, sync, share in one click or less
  4. Edit and delete anything allowed, share history until hard-deleted
  5. Link externally, build a profile, business card, resume, landing page
  6. Own & authenticate, delegate, share & find trust
  7. Verify claims
  8. Join a group, managed forward
  9. Chat, role-play, build & browse multi-user dungeons
  10. Exchange text, images, audio & video; store in Git; realtime A/V, stream content adaptively
  11. Self-locate and find neighbors
  12. Schedule, garden relationships
  13. Your hopes & dreams

For the technically inclined, what does this platform look like?
Cryptography applied to rebuilding JWT+JWS; sprinkle JSON-LD & JSON Patch, distributed messaging over WebSocket and WebRTC, share abstracted Git refs, a few URL tricks, & QR codes for link I/O in the physical world.

Make it easy to integrate your platform and to your platform (web standards).
Think and share components over entire apps (Lego bricks not paintings).
Build around local state and synchronization (offline-second).

To think silo = identity -> code + state & build distributed systems as pools of state machines behind queues,
watch Reactive Distributed Microservices on .NET (48 minutes);
to think of keypairs as identities, and messages as content from a sender to a recipient identities,
(re-)read my love & observe this short code example signing and encryption through asymmetric cryptography:

import nacl from 'tweetnacl';

const box = nacl.box
, randomBytes = nacl.randomBytes
, textEncoder = new TextEncoder()
, newNonce = () =>
    randomBytes(nacl.secretbox.nonceLength)
, b64 = (msg) =>
    Buffer.from(msg)
        .toString('base64')
        .replace(/=+$/, '')
        .replace(/\+/g, ',')
        .replace(/\//g, '.')
        // matching, mobile splits
        .replace(/(.{22})/g, '$1-');

const source = box.keyPair()
, target = box.keyPair();

const id = newNonce()
, encryptedAndSigned = box(
    textEncoder.encode(
        JSON.stringify({
            at: 1588646617,
            txt: 'hello!',
        })
    ),
    id,
    target.publicKey,
    source.secretKey
);

console.log(
    JSON.stringify(
        {
            _: 'B', // flags
            i: b64(id),
            a: b64(source.publicKey),
            b: b64(target.publicKey),
            m: b64(encryptedAndSigned),
        },
        null,
        4
    )
); /* => {
    "_": "B",
    "i": "ZOUNLaqBvyHzXmWHs1F,eF-
          b,J01aFTEt",
    "a": "n6Dl0uzS5tHjVsy1A2Yw5K-
          K,VATgPZru2AXWuUboFmg",
    "b": "VTIxMKH9WdKec4igy8Y,v6-
          ildPQyp2QdhNImdb.beXA",
    "m": "drW1oUpZY.hhjYubI2C.uc-
          4ab,NxoJMUzLOmKIqYazqU-
          rWcfRtDScbXCrI,mJ1Pr",
} */

To think functionally about those primitives, I find this helps:

derive: context -> identity -> context
locate: context -> url -> page
render: page -> store -> html
move: store -> action -> store * page