Hello there! Ryven is an editor combining flow-based visual scripting with Python. It provides an easy to use system for programming nodes executing any Python code.

Ryven is now based on ryvencore-qt, a guide for Ryven can be found here.

Ryven 3 and the new underlying framework haven't been tested extensively yet, so there might be some further changes incoming.

git clone https://github.com/leon-thomm/ryven
cd Ryven
pip install -r requirements.txt
cd Ryven/src
python Ryven.py

All information about a node is part of its class. A minimal node definition can be as simple as this

class PrintNode(Node):
    """Prints your data."""

    title = 'Print'
    init_inputs = [
        NodeInputBP()
    ]
    color = '#A9D5EF'

    def update_event(self, inp=-1):
        print(self.input(0))

You can define macros which get registered as nodes themselves

Macros are like all other scripts, so they have their own flow, plus input and output node

which can be edited through the API at any time.

class MyNode(Node):
    ...

    def a_method(self):
        self.actions['do something'] = {
            'method': self.do_sth,
        }

    # with some method...
    def do_sth(self):
        ...

You can add custom QWidgets for your nodes, so you can also easily integrate your existing Python-Qt widgets.

class MyNode(Node):
    main_widget_class = MyNode_MainWidget
    main_widget_pos = 'below ports'  # alternatively 'between ports'
    # ...

While data flows are the most common use case, exec flows (like UnrealEngine BluePrints) are also supported.

import logging

class MyNode(Node):
    def __init__(self, params):
        super().__init__(params)

        self.logger = self.new_logger('nice log')
    
    def update_event(self, inp=-1):
        self.logger.log(logging.INFO, 'updated!')

with an update mechanism to build nodes that automatically adapt to change of variables.

class MyNode(Node):
    ...

    def a_method(self):
        self.register_var_receiver('x', method=self.process)

    # with some method...
    def process(self, val_of_x):
        # processing new value of x
        ...

Also visit the website if you haven't been there already.

Ryven is now built on top of ryvencore-qt, a framework for building Ryven-like editors. Nodes from Ryven are easily migratable to other ryvencore-qt editors.

To support the development of this project, which will decide its future, check out the ryvencore-qt repo where the main development is happening.

Feel free to open discussions here (there's a discussions area in this repo).

The docs page on the website is made with Docsify, so you can improve it by simply editing the markdown.

Cheers.