• Stars
    star
    113
  • Rank 310,115 (Top 7 %)
  • Language
    Rust
  • License
    Other
  • Created over 6 years ago
  • Updated over 4 years ago

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

A library for creating and evaluating executable directed graphs at runtime.

gantz Actions Status Crates.io

A crate for creating and evaluating executable directed graphs at runtime. In other words, gantz allows users to compose programs described by interconnected nodes on the fly.

Gantz is inspired by a desire for a more flexible, high-performance, open-source alternative to graphical programming environments such as Max/MSP, Touch Designer, Houdini and others. Named after gantz graf.

NOTE: gantz is currently a research project and is not ready for any kind of real-world use.

Design Overview

Gantz allows for constructing executable directed graphs by composing together Nodes.

Nodes are a way to allow users to abstract and encapsulate logic into smaller, re-usable components, similar to a function in a coded programming language.

Every Node is made up of the following:

  • Any number of inputs, where each input is of some rust type or generic type.
  • Any number of outputs, where each output is of some rust type or generic type.
  • An expression or function that takes the inputs as arguments and returns the outputs in a tuple.

Graphs describe the composition of one or more nodes. A graph may contain one or more nested graphs represented as nodes, forming the main method of abstraction within gantz.

A Project provides an API for easily creating graphs, compiling them into Rust dynamic libraries and loading them ready for evaluation, all at runtime. The project manages a single cargo workspace that contains a single crate for each graph.

See the gantz/tests directory for some very basic, early proof-of-concept tests.

Included Crates

gantz_core Crates.io docs.rs

Contains the core traits and items necessary for any gantz implementation. The current approach heavily revolves around rust-code generation, however this crate may get generalised in the future to allow for more easily targeting other languages.

gantz Crates.io docs.rs

Provides implementations for the core traits and a high-level Project API for convenient use.

This repo does not provide any GUI itself - this will likely be implemented in a separate repository using nannou.

Goals

  • A simple function for creating nodes from rust expressions.
  • Allow for handling generics and trait objects within custom nodes.
  • Serialize and Deserialize for nodes and graphs via serde and typetag.
  • Project workspace creation.
  • Push evaluation through the graph.
  • Pull evaluation through the graph.
  • Simultaneous push and pull evaluation from multiple nodes.
  • Stateless node codegen.
  • Stateful node codegen.
  • Implement Node for Graph.
  • Conditional evaluation #21.
  • Evaluation boundaries #22.
  • Dynamic node I/O configurations #31.
  • A convenient API for managing node state #44.
  • A way to easily generate node types from existing fns in other crates.

After each of these goals are met, a new repository will be created where gantz will be extended using nannou to provide higher-level tools including:

  • A GUI for creating, editing and saving graphs and custom nodes at runtime.
  • Node packaging and sharing tools, likely built on cargo and crates.io.
  • A suite of nodes providing an interface to nannou's cross-platform support for a wide range of protocols and I/O:
    • Windowing and input events.
    • Phasers and signals.
    • Audio input, output, processing and device management.
    • 2D/3D geometry, graphics and shaders.
    • Video input and processing.
    • Networking (UDP and TCP).
    • OSC.
    • Lighting, lasers & control: DMX (via sACN), CITP (& CAEX), Ether-Dream.
    • GPU general compute.
    • General file reading and writing.

License

Licensed under either of

at your option.

Contributions

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

More Repositories

1

nannou

A Creative Coding Framework for Rust.
Rust
6,026
star
2

ether-dream

A full implementation of the Ether Dream Laser DAC protocol in pure Rust.
Rust
32
star
3

nannou_timeline

A GUI widget designed for viewing and controlling data over time.
Rust
25
star
4

guide

A guide for nannou, including "Getting Started", "Tutorials" and more.
Rust
25
star
5

hotglsl

A simple crate for hotloading GLSL shaders as SPIR-V.
Rust
22
star
6

isf

Parsing, Deserialization and Serialization of ISF - the Interactive Shader Format. Implemented in pure Rust.
GLSL
20
star
7

nannou_laser

A cross-platform laser DAC API featuring detection, streaming and frame optimisation in Rust.
Rust
19
star
8

nannou_audio

The audio API for nannou, the creative coding framework.
Rust
9
star
9

citp

An implementation of CITP (Controller Interface Transport Protocol) in pure Rust.
Rust
8
star
10

cpal_wasm_example

Example project for compiling CPAL to WASM and publishing on the web
JavaScript
5
star
11

nannou_osc

The OSC API for Nannou, the creative coding framework.
Rust
4
star
12

nannou_isf

A suite of tools aimed at making it easy to build your own live ISF shader editing environment with nannou.
GLSL
3
star
13

ilda-idtf

A library for efficiently reading and writing the ILDA Image Data Transfer Format.
Rust
2
star
14

lasy

A small library dedicated to LASER path optimisation.
Rust
2
star
15

notosans

A simple crate providing several of Google's Noto Sans true type fonts as slices of bytes.
Rust
1
star
16

website

nannou.cc | website
JavaScript
1
star
17

old_nannou_website

The Nannou website and blog
JavaScript
1
star
18

alembic-master

CSS
1
star
19

nannou_conrod

nannou's deprecated conrod interoperation crates, `nannou_conrod` and `nannou_timeline`.
Rust
1
star