ComfyTV: a canvas workbench that runs inside ComfyUI
ComfyTV — the canvas-based app that truly belongs to ComfyUI.
At a glance
- What is it?
- ComfyTV turns ComfyUI into a node canvas for the whole media pipeline, from generation through editing to export. It is installed as a custom node, and it ships roughly 190 stages across image, video, audio, music, panorama, 2D layers and 3D.
- Who is it for?
- Adopt ComfyTV if you already run ComfyUI locally and want generation, editing and export on one canvas without leaving the graph. Skip it if you want a lightweight node pack or a hosted service, because it is a full workbench with its own project storage, sidebar and asset libraries.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 5 days ago.
- What is it written in?
- Mainly JavaScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 17, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The gap ComfyTV fills between generation and delivery
ComfyUI is good at generation and awkward at everything after it. Once an image or a clip exists, the work moves to other applications: a layer editor for compositing, a video editor for cuts and grades, an audio tool for mixing, something else for the final export. Each hop loses provenance, and re-running one step usually means rebuilding the chain around it.
ComfyTV is aimed at people who would rather keep that work on the canvas. Its own description calls it "the canvas-based app that truly belongs to ComfyUI," and the README frames the goal as chaining stages into a complete flow: generate, pick, edit, composite, export. The audience is a ComfyUI user who already has local models and workflows and wants the downstream stages in the same graph rather than in four separate programs. It is not a hosted service and not a standalone editor; the install instructions assume ComfyUI is already running.
Per-node Run and snapshot outputs instead of the global queue
The mechanism that separates ComfyTV from ordinary node packs is how execution is triggered. Each stage runs on its own rather than through ComfyUI's global queue, and downstream stages consume the snapshot of an upstream stage's last output. Re-running a single node therefore does not drag the rest of the chain with it.
That choice has consequences worth naming. Because outputs are snapshots rather than live links, a downstream stage keeps working against the previous result until you deliberately re-run it. It makes experimentation cheap and it makes staleness possible: nothing forces a downstream node to notice that its input changed. The README does not document rollback, so how you recover a previous state is a question the documentation leaves open.
Around that execution model sits a project layer. Stages belong to a project, every output is kept with full history, and the state restores on reload. The repository layout reflects this: there are db.py, storage/, backup.py and settings.py at the top level alongside nodes/ and runners/, so project data and node logic live in separate places. Workflows ship under workflows/<kind>/ and run against your own local models. Any ComfyUI workflow can be imported as JSON, its inputs bound in a sidebar editor, saved as a per-stage preset, and starred as the default for that stage. Bridge nodes connect third-party plugins into a ComfyTV pipeline, and remote ComfyUI machines can be registered as extra runners in the Servers tab with a capability preflight.
Installing ComfyTV as a custom node and running a first stage
The README gives a two-step install. Clone the repository into your ComfyUI custom_nodes directory, then restart ComfyUI.
cd ComfyUI/custom_nodes
git clone https://github.com/jtydhr88/ComfyTVAfter the restart, ComfyTV nodes appear under the ComfyTV category in the Add-Node menu, grouped into sub-categories. That is the signal the install worked. The README is truncated at that point, so it does not spell out the next click; the documentation site at comfytv.org carries bilingual guides plus a per-node reference page for every stage, which is where the first-run material lives.
The package metadata is worth knowing before you clone. pyproject.toml declares version 1.9.0, an MIT licence, and an empty dependencies list, with a [tool.comfy] section naming the publisher and including the js directory. package.json is private, also 1.9.0, and pulls a substantial frontend stack: Vue 3, Pinia, three.js, TipTap, ag-psd, opensheetmusicdisplay, mediabunny and webm-muxer among others. That is a browser application shipped inside a Python custom node, and it explains why the sidebar, the in-node editors and the V2 skin exist at all. The repository also carries pnpm-lock.yaml and package-lock.json together, plus vite.config.mts and vitest.config.mts, so frontend build tooling is part of the project rather than an afterthought.
What roughly 190 stages actually covers, and where it thins out
The breadth claim is the easiest thing to be sceptical about, so it is worth listing what the README says is inside. Video is the largest block at around 100 nodes: edit operations like clip, split, concat and proxy generation; colour tools including wheels, curves, LUT, ASC CDL and HueCorrect; a keyer suite with PIK, Despill, KeyMix and Select0r; roto and tracking with bezier masks, point motion tracking and optical-flow mask propagation; 39 blend modes and 57 xfade transitions; an FX list running from glow and god rays to slit scan and feedback; 360 projection and stabilization; and infrastructure such as parameter expressions, an FX Chain that renders a stack in a single pass, and scopes.
Audio gets 30-plus nodes: dynamics, parametric EQ, loudness normalization, convolution reverb including room capture, stem split into vocals, accompaniment, drums, bass and other, and audio-reactive parameter automation. Music is symbolic rather than sampled, with a score stage using MusicXML, piano-roll score and MIDI editors, a SoundFont synthesizer and chord accompaniment. Image, panorama and 3D each have their own sets, and the 2D layer editor supports raster, text, vector-shape, parametric-fill and adjustment layers, per-layer masks, PSD import and export.
The honest caveat is that the documentation for all of this is a per-node reference, not a tutorial path. A per-node reference tells you what each stage does in isolation. It does not tell you which forty of the 190 stages you need for a given job, and the README does not claim otherwise. The broader storyboard-to-shot pipeline is listed as roadmap rather than shipped, so the Director console and the storyboard workbench are the current answer for sequenced work.
The layer editor is a separate project, and that matters for upgrades
The 2D layer editor and the storyboard workbench share one engine, and that engine is developed as its own project called Pentrado, with a standalone browser version at pentrado.com. This is a real architectural fact with real operational consequences. A bug in layer handling, PSD import or selection behaviour is likely to be fixed in Pentrado and pulled into ComfyTV rather than patched in place.
For anyone tracking versions, that means two moving parts instead of one. The README does not describe how the Pentrado engine is vendored into this repository, and the repository layout does not show an obvious vendored directory for it, so the coupling is something to check in the source before you depend on a specific behaviour. It also means the editor can be evaluated on its own terms before you install anything: opening pentrado.com in a browser is the cheapest way to decide whether the layer model suits you.
The same pattern shows up in the agent surface. ComfyTV ships an embedded Bot, a 45-tool MCP server and installable Agent Skills, with skill_store.py and skills/ present in the repository root. Those are three separate integration points, and each is documented in its own file under docs/. None of them are required for ordinary canvas work.
Where ComfyTV is the wrong tool
ComfyTV is a workbench, not a node pack, and that is the main reason to walk away. If your need is a handful of image operations inside an existing graph, cloning a project with a Vue frontend, a Pinia store, three.js, a database layer and a project history model is a large dependency for a small job. The empty dependencies list in pyproject.toml does not mean the install is light; it means the Python side declares nothing while the JavaScript side carries the weight.
Project-centric storage is the second boundary. Stages belong to a project and outputs are kept with full history, which is exactly what you want when you are iterating on a shot and exactly what you do not want when you are running a stateless batch. The README does not document a headless or queue-driven mode, and the per-node Run model is deliberately the opposite of ComfyUI's global queue. Anyone whose pipeline depends on submitting work to a shared queue should treat that as a mismatch rather than a missing feature.
The third case is remote and multi-user work. Remote ComfyUI machines can be registered as extra runners with a capability preflight, but that is about distributing compute, not about collaboration. Nothing in the README describes shared projects, permissions or concurrent editing, so a team looking for a collaborative canvas is looking at the wrong project.
As an alternative, consider staying with plain ComfyUI plus a conventional editing stack. The difference in approach is not feature count, it is where the state lives. Plain ComfyUI keeps execution in the global queue and hands finished assets to external tools; ComfyTV keeps execution per node and keeps every intermediate result inside a project. If your work is mostly one-shot generation, the first model is simpler. If your work is iterative, with the same shot going through generate, pick, edit, composite and export more than once, the second model is the one that saves the round trips.
Licence, maintenance and what an upgrade costs
ComfyTV is MIT licensed, stated in both LICENSE and the package metadata in pyproject.toml and package.json. MIT is permissive, so the usual obligations apply: keep the copyright notice and the licence text with any redistribution. That is the extent of what the repository states; nothing here is legal advice, and if you are shipping ComfyTV inside a commercial product you should read the licence yourself rather than take a summary.
The maintenance picture is straightforward. The repository is not archived, and the last push was on 2026-09-15, two days before this writing. That is a recent push, and it is the only maintenance signal available. There are no retrieved releases, so there is no changelog to read and no release notes describing what changed between versions. The version number in both pyproject.toml and package.json is 1.9.0, and those two files agree, which is a small but useful consistency check.
Upgrade cost depends on which surface you use. The Python side declares no dependencies, so a pull and restart is the mechanical part. The JavaScript side is where breakage would show up, and the repository carries both pnpm-lock.yaml and package-lock.json, which suggests the frontend has been built with more than one package manager over its life. Before upgrading a working install, check whether the frontend build output is committed or produced locally; the [tool.comfy] section includes the js directory, which indicates the built JavaScript is what ComfyUI loads. Because the layer editor tracks a separate project, a Pentrado change can arrive with a ComfyTV update, so PSD round-trips and layer behaviour are the things to re-check after a version bump rather than the node list.
Editorial conclusion
Adopt ComfyTV if you already run ComfyUI locally and want generation, editing and export on one canvas without leaving the graph. Skip it if you want a lightweight node pack or a hosted service, because it is a full workbench with its own project storage, sidebar and asset libraries. Before committing, clone it into ComfyUI/custom_nodes, restart, confirm the ComfyTV category appears in the Add-Node menu, and open the docs site's per-node reference for the stages you actually intend to use.
Frequently asked questions
What is ComfyTV?
ComfyTV is a canvas-based app that runs as a ComfyUI custom node. It turns ComfyUI into a canvas workbench with roughly 190 stages covering image, video, audio, music, panorama, 2D layers and 3D, chained as generate, pick, edit, composite and export.
What is the ComfyTV canvas?
The canvas is the node graph itself, where every operation is its own node and results flow downstream automatically. Stages belong to a project, and each output is kept with full history that restores on reload.
How do I install the ComfyTV app?
Clone the repository into ComfyUI/custom_nodes and restart ComfyUI. The ComfyTV nodes then appear under the ComfyTV category in the Add-Node menu, grouped into sub-categories.
Community notes