Macula Mesh Use Build Macula for… Docs Contact

Macula · sectors · All Macula for… pages

With Macula each connected device has its own key and dials out to the mesh, so it publishes readings and answers calls with no vendor cloud holding the data and no port open on the customer's router. The device's owner decides who gets its data. Without Macula, by contrast, a device reports to its maker's cloud, typically built on an IoT platform such as AWS IoT Core or Azure IoT Hub, and the maker stores every reading. We are looking for device makers to build it with.

Without Macula: every reading goes to the maker's cloud

A device you sell ends up in someone else's home, shop or field, on a network you do not control. To reach it, almost every maker runs an IoT cloud: the device reports to it, the owner's app queries it, and every reading the device takes passes through it.

readings copied out

A maker's IoT cloud stores every reading from every customer

What the device measures in a customer's home is stored on the maker's servers. One breach reaches every customer, and the customer usually cannot take their data elsewhere.

devices die with the cloud

A maker that shuts its IoT cloud stops its devices working

The servers cost money for as long as a device is in use. In 2016 Nest, owned by Google's parent Alphabet, shut down the servers behind the Revolv smart-home hub, and every Revolv hub stopped working, though nothing in them broke.

a port left open

Port forwarding opens the customer's router to internet-wide scanners

Reaching the device directly means forwarding a port on the customer's router, and an open port is found and probed by internet-wide scanners.

With Macula: each device is its own node and reports to its owner

The device runs a Macula node with an identity of its own. The node dials out to the Macula Mesh, a network of stations that link up to form the mesh, keep its phonebook (a Kademlia DHT: which node offers what, and where to reach it), and relay calls and messages between authorized members. One mesh carries many Macula Realms. Each realm is an identity space on the mesh with its own key: its operator admits anything that can be given an identity, such as people, organisations, services, machines and devices, gives each a certificate signed with that key, and can revoke it. Macula runs the community realm; a company or sector body can run its own under a Macula licence. The device publishes what it measures to whoever its owner allows, and answers the calls its owner allows, wherever the owner is.

Every device connects outward, so nothing on a customer's network has an open port facing the internet. Stations pass messages on and keep none of them; the admin of the maker's realm decides who and what is admitted, and nothing else. The maker runs no cloud to pay for or to leak.

What a device gets

A device that runs 64-bit Linux, on ARM or x86, can run a Macula node. Developers write for it in Python, .NET, TypeScript or Go. The device sees the same few ways to work with others as any other software on the mesh.

its own identity

A key on the device

Each device holds its own key, so the mesh knows it as itself: not an account in the maker's database, and not a shared password copied into every unit.

tell

Publish what it measures

The device publishes a reading as a fact, and every node that subscribed hears it. Each fact carries the device's signature, so no device can speak for another.

answer

Answer calls

The device offers a named procedure, such as "read the latest value", and its owner calls it by name from anywhere the owner is.

its own name

Services under its own id

Each device can offer services under its own id straight away, before any organisation has signed it up.

a household

Sealed groups

Devices that belong together publish to a group sealed under the group's key, so only its members read what is said in it.

come back

Reconnects after a dropped link

When a link drops, the node dials again and restores what it subscribed to and what it served. A subscriber is told when it may have missed something, so a gap is never taken for a quiet period.

The device sends its readings to its owner through relay stations that keep no copy. The maker stores nothing, so the device does not depend on the maker's servers; it does depend on reaching a station. Anyone can run one, as many as they like; the more stations, the stronger the mesh. Macula runs a number of seed stations and a community realm.

What Macula promises

no open door

No router opens a port

Every node connects out to a station; a station never dials in. There is nothing on a customer's network for a scan from the internet to find.

who may call

The device says who it serves

A procedure can be gated on a token the owner's key signed, or on a role the maker's realm granted. A call without one is refused before the device's code ever runs.

signed facts

No device can speak for another

Every published fact carries its publisher's signature, and the receiving node checks it before anything is delivered. A station that relays a fact cannot make it look like someone else's.

post-quantum

Post-quantum identities

Keys and signatures use the new methods chosen to resist future quantum computers, so a signature made today is not expected to be forgeable by one.

sealed content

End-to-end encrypted by default

Every call is sealed to the receiver's own key, and a group's facts to the group's key, so the stations in between carry only ciphertext. A call in the clear is refused unless the service has explicitly allowed it.

no vendor cloud

No vendor cloud stores the readings

Devices reach their owners through stations that pass messages on and keep no copy. The maker holds no store of what its customers' devices say.

Where it fits

Connected products installed on customers' networks, where the data should go to the owner and not to the maker's servers. With device makers we want to build the rest of the path: an identity given to each device at the factory or on its first boot, and a fleet that a maker can look after without ever holding its customers' data.

Devices in customers' homesInstruments out in fieldsProducts that outlive their maker's serversMakers who want no customer dataResearch instruments shared between groups

Build it with us

Partners bring the devices, the customers and the know-how of the hardware; we bring the node, the station software and seed stations, and each maker runs a realm of its own under a Macula licence. We are looking for partners in three roles.

put a node inside

Device makers

You build a connected product on Linux. Put a node in it with us, and shape how a device gets its identity when it is made.

build the app

Product companies

You sell the app and the service around a device. Build them with us on calls and signed facts, with no store of your customers' readings.

run a pilot

A first fleet

You have a handful of devices you are ready to put in real homes or fields. Run them with us on the mesh, owners hearing their own devices through relay stations that keep no copy, and you storing nothing.

In one sentence

Your devices send their readings to their owners through relay stations that keep no copy, and you store nothing.for device makers

A node per device with its own key, signed facts out, gated calls in, and no port open.for architects

Connected products that keep their owners' data and do not depend on the maker's servers; they do depend on reaching a station, and anyone can add more.for funders and policy makers