https://github.com/reactive-graph/reactive-graph

Reactive Graph and Flow Control
https://github.com/reactive-graph/reactive-graph

entity entity-component-system flow-control graph-database graphql inexor reactive-programming rust

Last synced: 19 days ago
JSON representation

Reactive Graph and Flow Control

• Host: GitHub
• URL: https://github.com/reactive-graph/reactive-graph
• Owner: reactive-graph
• License: mit
• Created: 2021-08-29T12:49:50.000Z (about 3 years ago)
• Default Branch: main
• Last Pushed: 2024-10-29T23:00:00.000Z (21 days ago)
• Last Synced: 2024-10-30T00:42:15.665Z (21 days ago)
• Topics: entity, entity-component-system, flow-control, graph-database, graphql, inexor, reactive-programming, rust
• Language: Rust
• Homepage: https://reactive-graph.io/
• Size: 82.1 MB
• Stars: 12
• Watchers: 3
• Forks: 0
• Open Issues: 49
• Metadata Files:
  • Readme: README.md
  • Changelog: CHANGELOG.md
  • Contributing: CONTRIBUTING.md
  • Funding: .github/FUNDING.yml
  • License: LICENSE.md
  • Code of conduct: CODE_OF_CONDUCT.md
  • Security: SECURITY.md

Awesome Lists containing this project

README

        


  



Reactive Graph




[](https://docs.reactive-graph.io/book/)

[](https://docs.reactive-graph.io/docs/)

[](https://www.rust-lang.org/)

[]()

[](https://github.com/reactive-graph/reactive-graph/blob/main/LICENSE.md)

[![Build](https://github.com/reactive-graph/reactive-graph/actions/workflows/rust.yml/badge.svg)](https://github.com/reactive-graph/reactive-graph/actions/workflows/rust.yml)

[](https://discord.com/invite/acUW8k7)



What is this?




➔ The `Reactive Graph` is a **graph database**

➔ The `Reactive Graph` is a **document store**

➔ The `Reactive Graph` is a **flow control** runtime

➔ The `Reactive Graph` is **pluggable** and **extensible**

➔ The `Reactive Graph` is **fast**, **secure** and **small**



What is it for?




➔ Game Entity Component System (ECS) - especially for [Inexor](https://inexor.org/)

➔ Smart Home and Internet of Things

➔ Data Conversion Tools

➔ Flow Control System for card size computers and embedded devices

➔ Desktop Automation

➔ Content Management System

➔ Knowledge Graphs and Knowledge Processing



Graph




A **graph** organizes highly interconnected data. The state of an `Entity Component System` can be ideally represented

with the help of the graph.

The main benefits of a graph are:

* A universal data structure for everything

* Relations are first class citizens

* Benefit from types and instances which makes things intuitive

* Benefit from navigation which is fast and intuitive

* Benefit from the semantics of highly connected, intuitive data

* Properties can store not only certain primitive data but complete documents



Reactive




Now that we understand how data is stored, here's how data interacts. The approach is that the data itself is "alive".

To do this, **Reactive Graph** adopts a concept from reactive programming.

In computing, reactive programming is a declarative programming paradigm concerned with data streams and the

propagation of change.

It is the ingenious combination of a graph with reactive programming. The property instances are not static

and only contain data. Rather, they are streams of data. If you change the value of a property instance, you

fill the data stream of this property instance. Data streams are linked together. For example, if the stream

of one property instance is linked to the stream of another property instance and you change the value of the

first property instance, the value of the second property instance will automatically change as well. Data is

thus propagated from one station to the next, triggering a cascade of propagations.

In addition, **Reactive Graph** remembers the last value in each property instance. This is done by subscribing to your

own data stream and caching it. This allows subsequent querying of the value of a property instance.

Remember this basic concept:

* Every property is a stream not only data

* Property streams can be subscribed and published

* The streams of two properties can be connected and changes will be propagated (cascade)



Behaviour driven design




The data flow is therefore automatic. Building on this, **Reactive Graph** applies the concept of behaviour-driven design.

The goal is to use these data streams to simulate behaviour.

Behaviors can be implemented on components, entities and relations. To do this, one or more incoming data streams

are combined, calculations are performed and written to one or more outgoing data streams.

For example, the entity type "AND gate" implements a behavior by subscribing to the two input properties, combining

them into a combination data stream and performing an AND operation on the incoming pairs of values. The result of

the AND operation is itself a data stream and this is linked to the output property.

This example shows how an entity type is wired internally. They are all data streams that are cleverly combined

with one another and thus depict behavior.

It is interesting that this behavior also works for relations. For example, connectors are also implemented

behaviors of streams. It is interesting that connectors connect the data stream from a property instance of the

outgoing entity instance with the data stream from a property instance of the incoming entity instance.

For example the AND-Gate accepts inputs at the properties lhs and rhs. Both streams are subscribed and zipped.

The zipped stream is calculated with a function - in this case the AND-Operator. This results in another

(invisible) stream which is connected with the property result. The entity type AND-Gate defines that the

properties lhs, rhs and result have to exist. Furthermore, the socket types are defined: lhs and rhs are

Input-Sockets and result is a Output-Socket. The behaviour is like the internal wiring of entity instances and

of relation instances. A behaviour can be added to entity instances and removed from entity/relation instances.



Flow




Control flows can be implemented based on the graph, the data streams and the behavior-driven design. It is

important here that the available modules that implement the behavior are linked with connectors.

For example, a flow can consist of a logic that links several AND gates with each other using connectors. Both

the AND gate and the connector are behaviors. But the arrangement of these behaviors within a flow makes them

powerful.

Entire game modes can be implemented with the help of flows. Or just parts of it that are used in multiple game

modes, such as a mechanism to pick up, drop, and score flags.

Flows are also useful for making maps more interactive. With the help of flows and behaviors, it can be ensured

that a door opens in a map when you press switch 1 and switch 2. Or you determine the color of your own team's

base based on the current score. Or you control particle emitters, depending on how many players are near the

emitter. The possibilities for this are endless and want to be used!



Plugins




[The Plugin System](https://docs.reactive-graph.io/book/Plugin_System.html)

[List of Plugins](https://docs.reactive-graph.io/book/Plugins.html)

[Plugins Repository](https://github.com/reactive-graph/plugins-core)



Development




[Build Instructions](https://docs.reactive-graph.io/book/Development_Build.html)

[Data Model](https://docs.reactive-graph.io/book/Model.html)

[GraphQL API](https://docs.reactive-graph.io/book/GraphQL_API.html)

[Dynamic Graph API](https://docs.reactive-graph.io/book/Dynamic_Graph_API.html)



Configuration




[Configuration](https://docs.reactive-graph.io/book/Configuration.html)



GraphQL Type System






Flow Editor




Coming soon.