@textile/threads-net-grpc NPM

go-threads

Textile's threads implementation in Go

Go to the docs for more about Textile.

Join us on our public Slack channel for news, discussions, and status updates. Check out our blog for the latest posts and announcements.

What's new

This table provides a brief overview of the features and new benefits built into threads. Status indicates where/when the feature will be implemented (green means it is complete).

Feature	Status	Description
Database
`Single-writer Logs`	complete	Threads use a single writer per log, and logs are ‘combined’ under a given Thread. SWLs make it is easier to add and remove writers and simplify conflict resolution (think of things like Git and Secure Scuttlebutt). One primary benefit of SWLs is that it means you don’t have to bake your conflict resolution strategy into the protocol. Projects that require eventual consistency can use CRDTs, whereas projects that require explicit ordering can use operational transform strategies.
`Multi-layer encryption`	complete	Threads use a multi-layered encryption approach, where content, read, and replication capabilities are granted by separately generated keys managed with each log in a Thread. Threads are capable of configurations such as public feeds (single writer), collaborative documents (multiple writers), or mixed documents (multiple writers, multiple readers). Don’t need encryption? No problem, turn it off.
Networking
`Multiaddress logs`	complete	Every log in a Thread has a unique multiaddress. Per-log multiaddress allow developers to build logs into new protocols, build the log protocol into new implementations, and integrate with future services.
`Push and pull`	testing	Threads peers take advantage of both push (think Pubsub and messaging apps) and pull (think HTTP and call-and-response style protocols) to exchange messages. Thanks to tools like libp2p, each collaborating peer can connect and exchange data with their peers using the mechanisms most suited to their current context (be it mobile, desktop, server, or wrist watch)..
`Scalable, verifiable follow`	development	Each thread also contains a pubsub based channel that can be used to serve log updates to pools of followers (and readers). The pubsub channel is particularly useful in cases where there will be many followers that aren't capable of updating a Thread but are interested in reading the updates from the owners.
`Access control`	design	Decentralized access control is hard, pretty much by definition. The Threads protocol approaches access control from an agent-centric perspective, which means collaborating peers are in charge of enforcing their access control. But what about when you want to change who can access what in a given Thread? You fork it (think Git/Github)! Think simple mechanism means that access control lists for a given Thread are immutable and easier to enforce, but can change over time as the requirements of a Thread change.

Install

go get github.com/textileio/go-threads

Usage

Go to https://godoc.org/github.com/textileio/go-threads.

Libraries

The following includes information about libraries built using go-threads.

Name	Status	Platforms	Description
Thread Clients
`js-threads-client`			A JavaScript client for threads daemon.
`dart-threads-client`			A Dart client for threads daemon.
Examples
`go-foldersync`			An e2e demo to sync data between two golang clients.
`js-foldersync`			A demo of writing and reading to Collections with the js-threads-client.

Contributing

This project is a work in progress. As such, there's a few things you can do right now to help out:

Ask questions! We'll try to help. Be sure to drop a note (on the above issue) if there is anything you'd like to work on and we'll update the issue to let others know. Also get in touch on Slack.
Open issues, file issues, submit pull requests!
Perform code reviews. More eyes will help a) speed the project along b) ensure quality and c) reduce possible future bugs.
Take a look at the code. Contributions here that would be most helpful are top-level comments about how it should look based on your understanding. Again, the more eyes the better.
Add tests. There can never be enough tests.

Before you get started, be sure to read our contributors guide and our contributor covenant code of conduct.