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
• Developer: Papaltine
• 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

Who Should Use ProtoGraph?

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

Benefits

• Readable: Clean syntax that mirrors ProtoFlux
• Modular: Encourages reusable and easy to refactor code
• Reliable: Compiler checks help catch errors early
• Accessible: Friendly to those familiar with ProtoFlux as a first programming language

Building and Using in Resonite

Getting Started

1. Write your .pg file
2. Compile it:

flux-sdk build MyModule.pg

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

Cross Product Module

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

module CrossProduct

in A: float3
in B: float3

out this: float3

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

// 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.

module Counter

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

// Public methods
out Increment: Impulse
out Decrement: Impulse
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;
}

See Also

• ProtoGraph Language Guide
• Git Repository
• ProtoFlux
• Dataflow Programming [Video]