The Picsart Flow canvas just got faster, clearer, and easier to organize. Three updates ship together in this release, and they all target the same problem: the friction that shows up once a project grows past a handful of nodes.<\/p>\n
Picture a canvas halfway through a real build. A reference photo feeds a background remover. That feeds a storyboard generator, and the storyboard feeds a video node. Two long prompt blocks sit underneath, wired into different stages. Four generations are running. The arrangement made sense an hour ago. Now the project has grown sideways and needs regrouping.<\/p>\n
Nothing on that canvas is broken. Every change to it is just slow.<\/p>\n
These are canvas features, not generation features. The models were never the thing slowing down a fifty-node build. The minutes went to the work around them, and that is what this release speeds up.<\/p>\n
Here is the short version of what changes.<\/p>\n Three things set the pace on a large Flow project: rewiring connections, tracking generations across the canvas, and resizing frames without moving the nodes inside. This release speeds up all three.<\/p>\n Model speed is what brings this into focus. Results land in seconds now, so the canvas work around them decides how fast a project moves. Connecting, checking, adjusting: small actions repeated through a session add up to the real timeline.<\/p>\n Two new gestures handle the part of canvas work nobody enjoys: rewiring.<\/p>\n Hold Cmd or Ctrl and right-drag across the canvas.<\/strong> A cut line follows the cursor, and every connection it crosses disconnects the moment you release.<\/p>\n The whole cut counts as one action. A single undo brings everything back if the stroke went wider than intended.<\/p>\n Hold Shift and drag from a node’s output handle<\/strong>, then move near the input handles of the nodes you want to reach. Each one joins a connection queue as you pass it.<\/p>\n Live indicators mark which targets accept the connection and which do not, so you are not guessing mid-drag. Release to create every compatible connection in one transaction.<\/p>\n Releasing Shift before you finish cancels the whole action, so the gesture is safe to explore with.<\/p>\n An upscaler sits in the middle of a pipeline and needs swapping for a different one.<\/p>\n The old way:<\/strong><\/p>\n Six connections, roughly a dozen precise clicks, and a good chance of grabbing the wrong wire on a dense canvas.<\/p>\n The new way:<\/strong><\/p>\n Two gestures.<\/p>\n Both gestures are listed in the shortcuts panel under a new Connections section. They also follow collaboration permissions, staying available to editors and disabled for read-only and comment-only collaborators.<\/p>\n The Run Queue Panel answers a question that used to require scrolling: what is actually happening right now?<\/p>\n Look at the bottom-left corner of the canvas, just above the credits indicator.<\/strong> The panel sits docked there and collects every pipeline generation in the project.<\/p>\n A spinner and an active-run count show what is in flight, a completion icon marks what finished, and an unseen-runs badge flags results you have not opened. Failed runs turn red and keep their error messages until you dismiss them.<\/p>\n Active runs sit at the top, and the list holds the 20 most recent, newest first.<\/p>\n Batch work, first of all. Fire six variations of a video node, keep building elsewhere, and the queue reports back as each one lands. The old approach meant remembering which six nodes you triggered and checking them one by one.<\/p>\n Teams, second. Collaborator and webhook runs appear automatically, and badges and seen states are tracked per person, so a teammate clearing their view does not clear yours. On a shared canvas the hard question has always been whether a generation is stuck, finished, or was never yours.<\/p>\n Through all of it the panel stays quiet: no notifications, no sounds, no toasts stacking up while a batch finishes. It updates in place.<\/p>\n Frames keep a canvas readable, and until now resizing one from its top or left edge came with a tax: every child node moved along with it.<\/p>\n Hold Cmd or Ctrl while resizing<\/strong> and only the boundary changes. Child nodes hold their exact canvas positions, and the frame resizes around the content already sitting there. Stretch it to pull in two neighboring nodes, or pull it back to tighten a section, and the arrangement you spent time building stays where you left it.<\/p>\n The standard resize behavior is unchanged, so existing habits still work. Undo reverts the boundary change and nothing else.<\/p>\n Open any Picsart Flow<\/a> project with a few connected nodes in it and run through the four actions below. There is nothing to enable first.<\/p>\n Three habits are worth revisiting once the gestures are in your hands.<\/p>\n Restructure more often.<\/strong> Rewiring used to cost enough that a pipeline built on an early assumption stayed that way. Cutting a branch and reconnecting it now takes two gestures. Restructuring mid-project gets cheap, and mid-project is usually when you learn what the project needed.<\/p>\n Run wider batches.<\/strong> Tracking overhead is what keeps people at three variations instead of six. The queue reports on everything at once, so the reason to stay conservative is gone. More variations is generally how better output happens.<\/p>\n Group late instead of early.<\/strong> Frames that resize without disturbing their contents can follow the work rather than lead it. Build the section, then draw the boundary.<\/p>\n None of this asks you to learn a new mental model. The canvas behaves the way it always did, with fewer steps between deciding on a change and making it.<\/p>\n The savings scale with complexity. The fastest way to feel the difference is to open a project you already built rather than starting a fresh one. A canvas with dense wiring, a few frames, and a habit of running batches will show it within a minute.<\/p>\n Open Picsart Flow<\/a> and try the gestures on a pipeline you know well. The Flow templates<\/a> library is the other good starting point, with working multi-node pipelines you can rewire without building the graph first.<\/p>\n More canvas improvements are in progress, and this release is three steps along that path.<\/p>\n\n\n
\n \nOn the canvas<\/th>\n Before<\/th>\n Now<\/th>\n<\/tr>\n<\/thead>\n \n Removing connections<\/td>\n Delete them one by one<\/td>\n Draw a single cut line through all of them<\/td>\n<\/tr>\n \n Linking one node to many<\/td>\n Repeat the same drag for every target<\/td>\n Hold Shift and connect them all in one drag<\/td>\n<\/tr>\n \n Tracking generations<\/td>\n Hunt across the canvas for what is running<\/td>\n Read every run in one panel, live<\/td>\n<\/tr>\n \n Resizing a frame from the top or left<\/td>\n Child nodes get pushed around<\/td>\n Nodes keep their exact positions<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n Why canvas speed matters now<\/span><\/h2>\n
Cut and connect in a single gesture<\/span><\/h2>\n
Scissors<\/h3>\n
Multi-Connect<\/h3>\n
What that saves<\/h3>\n
\n
\n
Every generation in one panel<\/span><\/h2>\n
Status at a glance<\/h3>\n
One-click control<\/h3>\n
\n
Where it pays off<\/h3>\n
Resize frames without breaking the layout<\/span><\/h2>\n
How to try each one<\/span><\/h2>\n
\n\n
\n \nWhat you want to do<\/th>\n The gesture<\/th>\n What you should see<\/th>\n<\/tr>\n<\/thead>\n \n Cut several connections at once<\/td>\n Hold Cmd or Ctrl, then right-drag across them<\/td>\n A cut line follows the cursor, and everything it crosses disconnects when you release<\/td>\n<\/tr>\n \n Link one node to several others<\/td>\n Hold Shift, then drag from the node’s output handle<\/td>\n Indicators mark compatible and incompatible targets, and every link lands at once<\/td>\n<\/tr>\n \n See what is running<\/td>\n Look bottom-left, above the credits indicator<\/td>\n The Run Queue Panel with live status, a spinner while running, and the last 20 runs<\/td>\n<\/tr>\n \n Resize a frame without moving nodes<\/td>\n Hold Cmd or Ctrl, then resize from the top or left edge<\/td>\n The boundary moves on its own and the child nodes stay exactly where they were<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n What changes about the way you build<\/span><\/h2>\n
Start with a canvas that is already crowded<\/span><\/h2>\n
Get answers to common questions<\/h2>\n \n