ComfyUI_Custom_Nodes_AlekPet: pose, painter and translation nodes for ComfyUI

What ComfyUI_Custom_Nodes_AlekPet adds to a stock ComfyUI graph

ComfyUI ships with the graph engine and a base set of nodes. It does not ship a pose editor, a sketch canvas, or a translation step between your prompt and the text encoder. This pack fills those gaps. The README lists eighteen nodes across nine folders, and the pyproject.toml repeats the same list in its description field, so the two agree on scope.

The audience is narrow and specific. You draw poses or scribbles for ControlNet and you would rather do it in the browser tab where the graph runs. Or you write prompts in a language other than English and want the translation to happen inside the workflow instead of in a separate window. Or you want to call a GLM model for translation, instruction following, image generation or video generation from a node. If none of those describe you, the pack adds nothing to your setup.

One thing worth noticing up front: the nodes are grouped by folder, and each folder is a separate concern with its own dependency set. PoseNode and PainterNode are the image-side nodes. GoogleTranslateNode, DeepTranslatorNode, ArgosTranslateNode and ChatGLMNode are four parallel translation implementations. ExtrasNode holds three small utilities, and IDENode is the odd one out, a node that runs Python or JavaScript you type into it.

The mechanism: per-folder node packages loaded from custom_nodes

ComfyUI discovers custom nodes by scanning the custom_nodes directory at startup. Each subfolder there is a Python package, and a top-level __init__.py in this repository ties the subfolders together. That is the whole architecture. There is no service, no daemon and no separate process. The nodes run inside the ComfyUI process, which is why the README can say the nodes are installed automatically once the folder is in place and ComfyUI is started.

The frontend side lives in web_alekpet_nodes, and the repository's primary language is JavaScript. That matters for the two editor nodes. A pose editor and a sketch canvas need a browser UI, so they carry JavaScript that ComfyUI serves to the page, while the Python side handles the tensor and image work. The other groups are mostly Python wrappers around external libraries.

The translation nodes split by backend. GoogleTranslateTextNode and GoogleTranslateCLIPTextEncodeNode use the googletrans module. DeepTranslatorTextNode and DeepTranslatorCLIPTextEncodeNode use Deep Translator. ArgosTranslateTextNode and ArgosTranslateCLIPTextEncodeNode use Argos Translator. Each pair comes in two shapes: one returns a string, the other returns conditioning. That distinction is the one that trips people up, because a string output will not plug into a sampler input that expects conditioning.

The ChatGLM folder is broader than translation. ChatGLM4TranslateTextNode and ChatGLM4TranslateCLIPTextEncodeNode translate. ChatGLM4InstructNode generates a prompt. ChatGLM4InstructMediaNode describes what is shown in media. ChatGLMImageGenerateNode generates an image from a text prompt, and ChatGLMVideoGenerateNode generates a video from a text prompt or an image. Those last two do work that overlaps with what a diffusion graph already does, so read the node documentation before assuming they replace anything.

Installing ComfyUI_Custom_Nodes_AlekPet with git clone

The README gives two routes. The manual route is to download the repository, extract the ComfyUI_Custom_Nodes_AlekPet folder and place it inside custom_nodes. The git route is shorter. Install Git, open a command window in your ComfyUI custom_nodes folder, and clone.

git clone https://github.com/AlekPet/ComfyUI_Custom_Nodes_AlekPet.git

After the command finishes you should see a ComfyUI_Custom_Nodes_AlekPet folder next to your other custom node folders. The README notes that this folder is created by the clone itself, so you do not create it by hand first. Then start ComfyUI.

On Windows the README describes two ways to get a shell into the right directory. You can click the folder path panel, type cmd and press Enter, or press Windows+R, open cmd.exe, and type the cd command with your own path.

cd /d your_path_to_custom_nodes

Replace your_path_to_custom_nodes with the real path. The /d flag is what lets cd change drive letters on Windows, so keep it if your ComfyUI install is on a different drive from the shell's starting directory.

For a first real use, start with the smallest node rather than the editor. PreviewTextNode sits in the AlekPet Node/extras category and displays the input text. Wire a text node into it and run the graph. If the node appears in the menu and shows your string, the package loaded and the folder structure is correct. Only then move to PoseNode or PainterNode, which need the browser UI to load before the canvas appears.

The README does not document a pip install step, a requirements file, or per-node dependency installation. The repository has a pyproject.toml with project metadata and a tool.comfy section carrying PublisherId, DisplayName and Icon, but the README's install section stops at placing the folder and restarting ComfyUI. If a translation node fails on import, the missing piece is the library named for that node, and you will have to install it yourself.

Where the pack breaks down: dependencies, backends and the IDE node

The largest limitation is that dependencies are not declared in the install instructions. The README names googletrans, Deep Translator and Argos Translator as the modules behind the translation nodes, but it does not tell you how to install them or which versions work. If your environment lacks one of those libraries, the corresponding nodes will fail while the rest of the pack loads fine. That is a per-node failure, not an all-or-nothing one, which makes it harder to notice.

The Google translation path has a second problem. googletrans is an unofficial client for a service that can change behaviour or block requests without notice. A workflow that depends on it can stop producing translated prompts for reasons that have nothing to do with your graph. The Argos path is the opposite trade: it runs locally, so it does not depend on a remote service, but the README gives no guidance on model downloads or language coverage, and local translation models are typically weaker on unusual phrasing than the hosted options.

The ChatGLM nodes assume you have access to a GLM endpoint. The README does not document authentication, endpoint configuration or rate limits for those nodes, and the repository has no releases listed, so there is no changelog describing how that integration has changed. Treat the ChatGLM group as the least documented part of the pack.

IDENode deserves its own warning. It runs Python or JavaScript that you type into the node. That is a deliberate design choice in a local tool, but it means a shared workflow file can carry executable code. The README describes the capability and says nothing about sandboxing. If you open workflows from strangers, read the IDENode contents before running the graph.

How it compares with ComfyUI-Custom-Scripts and other node packs

The closest comparison is ComfyUI-Custom-Scripts, which appears in the search data around this project. That pack concentrates on the editing experience: text widgets, autocomplete, small interface conveniences. It does not give you a pose canvas or a translation backend. The overlap is small, and running both is normal.

The bigger difference is against ComfyUI Manager. Manager solves discovery and installation: it lists node packs and installs them for you. This repository solves capability: it adds nodes that do not exist elsewhere. They are complementary, not alternatives, and the README installs by manual clone rather than through Manager. If you prefer Manager to handle installation, this pack is not written around that path.

The translation nodes also have an alternative inside ComfyUI itself: write your prompt in English and skip the translation step. That is the honest comparison. A translation node adds a failure point and a latency cost between your text and the encoder, and for short prompts the manual route is often faster overall. The node earns its place when you iterate on long prompts in another language and retyping them in English each time is the real bottleneck.

For pose and sketch input, the alternative is drawing in an external editor and loading the result as an image. That works and needs no extra node. The pack's advantage is that the canvas sits in the graph, so the pose and the prompt stay in one file you can save and reuse.

Maintenance, upgrades and the MIT licence

The repository is not archived, and the last push was on 2026-08-27, which is recent. There are no retrieved releases, so upgrades happen by pulling the master branch rather than by picking a tagged version. The pyproject.toml records version 1.1.9, which gives you something to compare against after a pull, but nothing in the README explains what changed between versions.

That shapes the upgrade cost. Because there are no releases, you cannot pin to a known-good tag from the release page. You can pin by commit hash in your own deployment, and that is the practical way to keep a working setup stable. If you pull master and a node stops loading, the absence of a changelog means you will be comparing your own copy against the new one rather than reading release notes.

The licence is MIT, declared both in the LICENSE file and in pyproject.toml as license = { file = "LICENSE" }. MIT is permissive: you can use, modify and redistribute the code, including commercially, provided the copyright notice and permission notice travel with it. That covers this repository's own code. It does not cover the external services the nodes call. Prompts sent through the Google translation node leave your machine, and prompts sent through a ChatGLM node go to whatever endpoint you configure. Those are terms of service questions, not licence questions, and they are outside what the MIT file addresses. This is not legal advice; check the terms of each service you point a node at.

Editorial conclusion

Adopt this pack if you already run a local ComfyUI and want pose or sketch ControlNet input drawn inside the graph, or if your prompts are written in a language other than English. Skip it if you depend on managed cloud ComfyUI, where you cannot write into custom_nodes, or if you want a single vendor support contact for every node. Before committing, check which per-node dependencies your chosen nodes need (googletrans for the Google nodes, Deep Translator for the Deep translator nodes, Argos Translate for the Argos nodes), and confirm that the ChatGLM nodes point at a GLM endpoint you are allowed to use.

Frequently asked questions

Official sources

1. AlekPet/ComfyUI_Custom_Nodes_AlekPet on GitHub
2. Issues
3. License: MIT
4. Project website
5. README