URMA. GitHub

APPLICATIONS / ONE PROTOCOL, SIX SYSTEMS

Same records.
Different jobs.

Every system writes the same kinds of records and recovers them the same way. Capture is the first use case, built for journalists. The protocol is the product.

01 / CAPTURE

Journalism

Shot in the field.
Recovered from the chain.

Photos, video, documents and their context are encrypted under your key and written to the chain before anything is lost.

  • Encrypted and signed under your key before it leaves the device
  • Published into confirmed blocks before the loss
  • The newsroom holding the key recovers the originals with any reader
urma-files on crates.io
From camera to chain and back
Capture: from the camera to the chain and back to the newsroomA phone or camera encrypts and signs the material, which is written into confirmed blocks. The device is seized and that route is cut. The newsroom reader fetches the records from the chain and restores the originals with the newsroom key. PHONE · CAMERA ENCRYPT · SIGN CONFIRMED BLOCKS DEVICE SEIZED ROUTE CUT NEWSROOM READER YOUR KEY ORIGINALS

02 / GIT

Code beyond the host

Push once.
Clone from the chain.

A committed HEAD snapshot becomes a pack, split into data parts, leaf and root records, and written to the chain. urma git publishes and clones.

  • 841,133 bytes published as 6 commit/reveal pairs
  • Verified clone in about 2.11 s on Litecoin testnet
  • Checkout verified byte by byte against the root record
urma-git on crates.io
From HEAD to verified checkout
Git: from a HEAD snapshot to a verified checkout from the chainThe repository HEAD becomes a snapshot and a pack, split into data, leaf and root parts written into confirmed blocks. The hosting account is cut. urma git clone reads the records from the chain and produces a verified checkout. REPO HEAD SNAPSHOT PACK HOSTING ACCOUNT ROUTE CUT DATA DATA LEAF ROOT CONFIRMED BLOCKS urma git clone VERIFIED CHECKOUT

03 / WIRE

Public text you can verify

Signed by the author.
Read from the chain.

Posts, replies, profiles and avatars are signed records written straight to the chain. Readers build the feed from confirmed records.

  • Every record carries the author key and readers verify it
  • The feed is built from confirmed records only
  • A chain reorganization rolls the index back automatically
urma-wire on crates.io
From author key to feed
Wire: from the author key to a verified feedThe author key signs post, reply and profile records, which are written into confirmed blocks. The platform account is cut. A reader index builds the feed from the confirmed records and verifies each author key. AUTHOR KEY POST REPLY PROFILE CONFIRMED BLOCKS ROUTE CUT PLATFORM ACCOUNT READER INDEX FEED

04 / FILES & ARCHIVES

Private archives

Your tree.
Back in one piece.

A directory tree becomes a catalog plus encrypted private objects on the chain. Your key restores the whole tree.

  • One catalog plus encrypted private objects per tree
  • Every object recoverable on its own, catalog or not
  • Safe export to ordinary files
urma-files on crates.io
A directory, published and restored
A folder tree becomes a catalog and private objects on the chain, then is restored with your keyThree files in a folder tree are written as a catalog and encrypted private objects into confirmed blocks. The laptop is cut off. Any reader fetches the records from the chain and restores the whole tree with your key. FOLDER TREE FILE 1 FILE 2 FILE 3 CATALOG PRIVATE OBJECTS CONFIRMED BLOCKS ROUTE CUT LAPTOP YOUR KEY ANY READER TREE RESTORED

05 / WEB & NAMES

Sites and names, no central provider

Publish a site.
Resolve a name.

A site directory is packed into a URMAWEB1 package with pinned objects and published to the chain. The URMANAM1 registry resolves a name to the site’s root on chain.

  • The URMA browser reads sites straight from the chain
  • A portal gateway serves name-bound sites to any browser over HTTPS
  • Run your own portal and your own DNS in front of it
urma-web urma-names
A site and its name, two ways in
A site is packaged and published to the chain, a name resolves to its root, and readers reach it directly or through a portalSite files are packed into a package and written into confirmed blocks. A name is written to the registry and resolves to the site root. The web host is cut off. The URMA browser reads the site straight from the chain; a portal serves it to any browser over HTTPS, and anyone can run their own portal and DNS. WEB HOST ROUTE CUT SITE FILES PACKAGE NAME REGISTRY ROOT CONFIRMED BLOCKS URMA BROWSER PORTAL RUN YOUR OWNPORTAL + DNS ANY BROWSER · HTTPS

06 / CAMERA

URMA’s own device

Capture. Publish.
Recover from the device.

A field camera with the URMA engine on board. It captures, publishes and recovers on its own.

  • Modular WAN: satellite terminal, LTE, Wi-Fi
  • Power with solar input
  • Secure boot, secure element, repairable enclosure
Hardware & field stage
One device, every link
A field camera with the URMA engine publishes over satellite, LTE or Wi-Fi to confirmed blocks, and a newsroom reader recovers from the chainInside the device: a sensor, compute with the URMA engine, a secure element and solar-fed power. The engine publishes through any of three WAN links, satellite, LTE or Wi-Fi, into confirmed blocks. A newsroom reader recovers the records from the chain. DEVICE SENSOR SECURE ELEMENT COMPUTEURMA ENGINE POWER · SOLAR SECURE BOOT SATELLITE LTE WI-FI CONFIRMED BLOCKS NEWSROOM READER

BUILD ON IT

One engine.
Any workflow.

Fourteen Rust crates and the urma command line carry every system above.

Crates and CLI