User:Papaltine/ProtoGraph

ProtoGraph is a declarative programming language designed to work with ProtoFlux in the Resonite ecosystem. It allows creators to write logic in a clean, readable text format that compiles directly into ProtoFlux nodes—making it easier to build, test, and maintain complex systems.

Overview

Paradigm: Dataflow
Family: ML: Caml: OCaml: F#
Designers: Papaltine, Kittysquirrel
Developers: Papaltine, Kittysquirrel
Stable Release: N/A (Currently in Beta)
License: AGPLv3
Target Platform: Resonite (via ProtoFlux)
File Extension: .pg
Compiler Tool: flux-sdk
Repository: Flux SDK
Nuget: Papaltine.FluxSDK
Compiled Format: .brson (Resonite Record)
Influenced by: F#, Elm, Python, Haskell, VHDL, Odin, Go
Showcase World: https://go.resonite.com/world/U-1O4IcGhlKSm/R-2045c574-dda6-4a7e-9955-56d2ca002d78
Documentation

Who should consider ProtoGraph?

Creators who want to move beyond visual scripting
Developers building modular, reusable systems
Teams collaborating on large-scale projects

Benefits

Readable: Clean and concise syntax that mirrors ProtoFlux 1 to 1
Modular: Reusable and easy to refactor code using modules (nested nodes)
Version: Use industry standard tools to store, diff, share, and version control source code
Reliable: Compiler checks help catch errors early and even builds incomplete programs
Accessible: Friendly to those familiar with ProtoFlux even as a first programming language
Compatible: It's still just ProtoFlux under the hood and works with the rest of Resonite: no mods or plugins

When is ProtoGraph not a good choice?

Prototyping: For small tests and one-off examples, ProtoFlux is faster and easier to setup.
High Performance: Wait for WASM integration. ProtoGraph is only as fast as the ProtoFlux VM.
Visual-only Creators: ProtoGraph is a text version of ProtoFlux. It requires typing.

Building and Using in Resonite

Getting Started

Write your .pg file
Compile it:

flux-sdk build MyModule.pg

Import the .brson file into Resonite
Inspect the generated ProtoFlux under the corresponding slot

Flux UI

The Flux UI can be used in Resonite to link up the sources and drives from generated ProtoFlux.

Examples

Cross Product Module

This is a simple pure module that transforms input data into outputs.

/// Multiplies two 3D vectors using a cross product
module CrossProduct

/// The first vector
in A: float3
/// The second vector
in B: float3

/// The result of (A X B)
out this: float3

where {
    // Inputs
    Ax, Ay, Az = A->Unpack_Float3;
    Bx, By, Bz = B->Unpack_Float3;

    // Computations
    Cx = (Ay * Bz) - (Az * By);
    Cy = (Az * Bx) - (Ax * Bz);
    Cz = (Ax * By) - (Ay * Bx);

    // Final result
    Pack_Float3(Cx, Cy, Cz);
}

Counter Object

This shows how you can write an object that maintains internal state and exposes methods to be called.

/// A simple object state machine that can count up and down
module Counter

/// The current value of the counter
out this: int

/// Public method to count up
out Increment: Impulse
/// Public method to count down
out Decrement: Impulse
/// Public method that sets counter to 0
out Reset: Impulse

where {
    // Variables are not shared with other nodes, they are private
    sync CounterVar: int;

    // out impulses are methods on the object that send it messages
    // to do different actions
    Reset = CounterVar <- 0;

    Increment = CounterVar <- ValueInc(CounterVar);

    Decrement = CounterVar <- ValueDec(CounterVar);

    // We can also expose normal data. This is like a getter.
    CounterVar;
}