Try it in your browserpreview Source

0.36.x✎

A name lasts as long as its block, and a chain of conditions is one chain.

0.36.x2026-09-15

FeatureChangeBugfixEditorDesignerDocs

A name lasts as long as its block, and a chain of conditions is one chain.

Releases

  1. 0.36.7A knot hears its source change its mind.New2026-09-15
  2. 0.36.6A graph's coordinates are its own.New2026-09-15
  3. 0.36.5A copied comment brings what it is drawn around.New2026-09-15
  4. 0.36.4A paste lands where you are pointing.New2026-09-15
  5. 0.36.3A loop says what it is looping over.New2026-09-15
  6. 0.36.2A field read twice is written twice.New2026-09-15
  7. 0.36.1The node search asks the same scope question the panel does.New2026-09-15
  8. 0.36.0A name lasts as long as its block, and a chain of conditions is one chain.New2026-09-15

Warning

Worth knowing before you upgrade.
  • 0.36.7A knot was only retyped when a wire was added or removed. If one has been sitting on the wrong type, it corrects itself the next time you touch the graph.
  • 0.36.7Node Design's logic canvas does the same, as it does for everything else the canvas can do.
  • 0.36.6A copied function still keeps its body's layout. Only its declaration lands at the pointer; the nodes inside it stay where they are in the copy's own graph.
  • 0.36.5Delete is unchanged. Removing a comment removes the note and leaves the nodes, as it always has — a key that quietly took eleven nodes with it is not one to find out about by accident.
  • 0.36.5A node does not bring its comment. Copying something that happens to sit inside a comment copies the node, exactly as dragging it does.
  • 0.36.4With the pointer off the canvas, a paste still offsets from the original, which is what it always did. A keystroke does not say where the mouse is, and a mouse in a panel is not a place you chose.
  • 0.36.4A node inside a pasted function does not move. It keeps its position in that function's own graph, which is not the graph you are pointing at; only the declaration lands at the pointer.
  • 0.36.3An array's index is not offered a type. ipairs hands back a number, and writing i: number says what the loop already said.
  • 0.36.3The annotation follows the graph's typecheck mode, as every other one does: Strict and Nonstrict write it, Default does not. The pin is typed either way.
  • 0.36.3Blank means no annotation, not any, so a loop nobody has typed compiles to exactly the line it always did.
  • 0.36.2Naming the result still asks for the local, and is now the way to say "read this once and keep it" — worth it for an instance property read several times in a row, where each read crosses into the engine.
  • 0.36.2Recompiling will drop these locals from generated files. Every graph that read a field or a constant twice loses a line and reads the path at each use instead.
  • 0.36.1Script variables and functions are still listed everywhere. A variable is readable from anywhere by construction, and the list of a file's functions is how you move between them — neither is scoped, and neither is an oversight.
  • 0.36.0Recompiling a graph will reformat parts of the generated file. The parentheses, the elseif chains and any name that had picked up a 2 all change at once. The programs are the same; the diffs are not small.

Added

  • 0.36.6Copy, cut, paste and duplicate in Node Design's logic canvas, on the same terms as a graph. They live in the graph editor's shell, which the designer page does not have, so they had never been there. Node Inputs and Node Outputs are left out of all four — there is one of each and they are already present.
  • 0.36.3Key type and Value type on For Each, in the Inspector, and Value type on For Each (Array). Luau takes an annotation on a for binding, so it is written where the variable is introduced: for part: BasePart, transparency: number in pairs(parts) do.
  • 0.36.3The types reach the pins too. A Value typed BasePart gives a BasePart pin — coloured as one, and wired to things that want one — whether or not the annotation is written.
  • 0.36.0Key name and Value name on For Each and For Each (Array), in the Inspector. Left blank they are key and value, as before.
  • 0.36.0Cast, in the Inspector: Automatic is the old rule, Explicit always writes local part = value :: BasePart, and Implicit never writes a line.
  • 0.36.0An implicit Cast inside the True arm of a Branch on Is A writes nothing at all. Luau has already narrowed the value there. Two classes tested with Or narrow to the union, so a cast to Decal | Texture disappears in that arm and a cast to either half stays.
  • 0.36.0Brackets, on And, Or, Not and the comparison pills: wrap the result in ( ), or leave it to Luau's precedence.
  • 0.36.0New logic nodes, in Settings, chooses which of those a pill you drop starts as.
  • 0.36.0Indent with, in Settings: a tab, or 2, 3, 4 or 8 spaces. Written to roswaal.json as indentStyle and indentWidth, and handed to stylua as well.
  • 0.36.0Get ‹parameter› in the node search, one per parameter of every function and handler in the graph, with Get Parameter's From and Parameter already filled in.
  • 0.36.0A comment's colour, in the Inspector: eight swatches, or a hex typed in.
  • 0.36.0Drag a tab to reorder the row, and a list at the end of the row naming every open graph.

Changed

  • 0.36.7A knot in a drawn graph on these pages is coloured by what it carries too. The picture under Reroute knots drew two grey dots beside a paragraph saying otherwise.
  • 0.36.5Cut takes away exactly what it took a copy of. Cutting a comment removes the nodes it encloses, so the paste is the group rather than a second set of it.
  • 0.36.4Paste and Duplicate put the clipping's top-left corner at the pointer, instead of beside what it was copied from. The corner is the furthest up and left of everything in the clipping, comments included.
  • 0.36.4Ctrl+D goes to the pointer too, because a duplicate is a paste with a different source and had the same problem.
  • 0.36.2A plain access path read more than once is written again rather than hoisted into a local. restore.weld at both use sites, not local weld = restore.weld beside them — which is what hand-written Luau does, and what Occupancy.VALUE_NAME was already doing everywhere except through Get Key.
  • 0.36.2A path reached through a call still gets its local, because the call would otherwise run twice. So does an expression, and anything else that is work rather than a name.
  • 0.36.0A Branch wired into a Branch's False pin compiles to elseif. A chain of conditions is one if statement at one level of indentation, ending in one end, instead of a nested if per condition. A condition that has to work something out first still gets its own else block, because elseif has nowhere to put the line.
  • 0.36.0Parentheses are written where Luau's precedence needs them and nowhere else. not humanoid or not root rather than (not humanoid) or (not root).
  • 0.36.0A local's name is taken for as long as its block, not for the whole file. Two functions can both call a parameter character, and two loops can both call their value part; a name an enclosing block holds is still avoided, so nothing shadows.

Fixed

  • 0.36.7A reroute knot follows its source being retyped, without the wire having to be redrawn. Give a Declare Local a type, type a loop's Value, retype a function's parameter or a variable — the knots downstream take the new type, and so do the knots after those.
  • 0.36.7A wire dragged from an output connects to a knot. A knot's two pins are stacked at its centre, so the drop landed on the output whatever you aimed at, the two ends were both outputs, and nothing happened. Dragging from an input always worked, which is why knots looked like they sometimes took wires and sometimes did not.
  • 0.36.6A comment takes only what is in its own graph. Every graph of a file starts at the same origin, so a comment in the nodescript's graph and a function's nodes can sit at the same numbers — and a comment copied from one was coming back with nodes from the other.
  • 0.36.6Dragging a comment no longer moves nodes in a graph you are not looking at. The same question, asked by the drag since function graphs existed.
  • 0.36.6Paste lands at the pointer for anything copied inside a function's graph. It was testing whether a thing had been copied from the nodescript's own graph, which is no for everything copied while a function is open — so the pointer was ignored in exactly the graphs most of the work happens in.
  • 0.36.5Copying a comment copies the nodes inside it, and the wires between them. It used to copy the rectangle alone — so pasting gave an empty box, which then landed over whatever was already there and enclosed that instead.
  • 0.36.5A comment inside a copied comment comes too, with everything in it.
  • 0.36.4A copied comment no longer encloses the originals as well as the copies. Membership is worked out from the geometry when a drag starts, so a comment dropped on top of what it was copied from really did contain both — and dragging it afterwards took all of them.
  • 0.36.2A field read twice now really is read twice. The local was a snapshot: a Set Index between the two reads never reached it, so the graph said "read this field here" and the file did not.
  • 0.36.1The node search offers only the locals the graph on screen can reach. Searching restore in show's graph offered Get restore for a local that hide declares, and picking it gave a Get Local the compiler then refused. The Variables panel was scoped in 0.36.0; the search was not, and both now read one rule.
  • 0.36.1A parameter is offered only inside the body it belongs to. A function's in its own graph, a Connect or Once handler's where its node is drawn.
  • 0.36.0A graph whose own tab was closed while one of its function tabs stayed open can be opened again. It was still loaded, so opening it took the "already open" path and found no tab to go to; double-clicking it in the tree did nothing until the function's tab was closed. Its tab now comes back in front of its functions', keeping the history and any unsaved edits.
  • 0.36.0The Variables panel lists the locals and types the graph on screen can actually reach. A local declared inside hide was listed while show was open, and dragging it out gave a Get Local the compiler then refused. A file's own locals still show inside a Declare Function, which closes over them — but not inside a hoisted Function, which is written above them.