Remote String (GeN13)

Text in a big graph is the worst case of the repetition problem. A style block, a character description, a negative prompt - each of them needed by two or three encoders, each widget holding its own copy, and one of them silently out of date because you edited two of three.

Remote String (GeN13) is the clone-group answer for text. Same channel name on two nodes and they hold the same string. Edit either, the other follows, live. No wire, no re-typing, and it works through subgraph boundaries where dragging a link is painful.

Fields

• channel - the group name, default remote. Same type and same name = same group. A Remote String on channel style doesn't sync with a Remote Int on style.
• value - the text. Here's the structural oddity: value is an optional input socket forced onto the node (the little dot in the top-left), while the text you actually type lives in a text box the frontend draws for you. So if you connect something into the socket, that upstream string becomes the group's value and syncs live to every clone; if you don't, you type in the box.

Output: STRING, the shared text.

That socket is genuinely useful beyond typing. Feed it from an LLM node, a Prompt Cache, or a Text Switch and the whole group updates per run - one prompt source, many encoders, no fan-out wiring. And because it's a real widget value from the backend's point of view, the text also gets reported into the run history, so a history viewer can show what prompt produced a given image.

Where it's the right tool

The style block. Forty tokens of "shot on Portra 400, soft window light, muted palette" that three encoders need. One channel, done.

Negative prompts. Everyone has the same negative in four places and one of them has worst quality misspelled as worst qualty. Fix that permanently.

Two encoders for one concept. SDXL with separate base and refiner CLIPs, or any workflow that encodes the same text twice at different strengths. They physically cannot diverge.

Text that comes from elsewhere. LLM → Remote String's value socket → every encoder in the graph. That's a two-node prompt pipeline.

Installing

Manager → search GeN13 → install → restart. Manual:

cd ComfyUI/custom_nodes
git clone https://github.com/heigen13/ComfyUI-GeN13
pip install -r ComfyUI-GeN13/requirements.txt

One dependency, nvidia-ml-py, which the pack's monitor uses - nothing to do with this node. The remotes are frontend JavaScript plus a tiny Python class; the Python side just returns the string it was given. No models.

The two ways it goes wrong

The socket catches you. Because value is a socket, dragging a link into it hands control of the group to whatever's upstream. If your typed text suddenly stops having any effect, look at that dot - something is connected and quietly winning. This is also why a clone can look "broken" when it isn't: it's faithfully broadcasting an empty string from a disconnected upstream.

Channel collision. The default is remote, and it's shared with the Int, Float and Boolean nodes as a name (though not as a group). Two unrelated blocks both left on remote will sync with each other and you'll type a negative prompt into a style channel and watch your image go strange. Name things: style, neg, character, text_note.

One limitation to know going in: sync is per-type and per-name only. There's no "this channel is a prompt, that one is a filename" distinction, so a small amount of naming discipline is load-bearing.

Should you, though

The trade-off is the same one that got "anything goes anywhere" nodes their backlash years ago: removing a wire removes a thing you could see. In a graph with five encoders, one prompt source with no spaghetti is worth it. In a two-node graph, the core primitive and a wire is less machinery for the same result, and nobody will ever have to guess where the text came from.

Where Remote String really beats a primitive is the case a primitive can't handle at all: the same value needed inside a subgraph, or in a branch on the far side of a canvas you've stopped scrolling.