TreeScale: Highly scalable PubSub system

TreeScale is a technology which allows to build real-time PubSub applications with highly-scalable architecture, using Math Tree/Graph-based scalability instead of standard horizontal scalability.

The goals and main philosophy behind TreeScale:

1. Keep always alive TCP connections - This principle allows to avoid infinite request/response cycles, and giving more network efficiency, faster fail detection, and more secure communication.
2. Completely Decentralized Services - Decentralized services are the key for infinite scalability and maximum performance, where one application is fully independent from another application and the base communication made by event handle/emmit.
3. Stay Platform and Technology Independent - The abstraction layer over infrastructure should be independent from application technology stack and all kind of data transfer should be packaged as an event for safe distribution, transfer, broadcasting.

Building

For building from source you will need Rust language installed. There is only one command for building this project on all platforms which is supported by Rust.

This project is mainly tested on Linux, BSD, Windows, macOS and Android (experimental).

~# git clone https://github.com/treescale/treescale
~# cd treescale

# Building with Rust package manager
~# cargo build --release

# After building see what we have now!
~# ./target/release/treescale --help

Roadmap for release

• [x] Distributed Tree/Graph structure with automatic lookup
• [x] Event path calculation between Tree/Graph nodes
• [x] API client subscriptions for each node and event delivery
• [x] Event broadcasting and round robin load balancing using stateful path calculation
• [ ] API Libraries for major programming languages (JavaScript, Go, Java, Python etc...)
• [ ] Queue system for each node with persistent storage (probably using RocksDB Key-Value database)
• [ ] Benchmarking with existing PubSub platforms
• [ ] Mobile integration for real time massive data delivery (already tested!)

Contributions are welcome!

This project written in Rust because it is giving real guaranties for preventing data races and completely handles memory management without garbage collection, which is giving huge performance improvements and low memory usage.

Project structure is simple, and everything is wrapped around single Node structure and associated traits.

Feel free to send pull request, open an issue even if it's not a code improvements.