๐ ComfyUI TJ_NODE v2.0.1
Revolutionize Your Workflows with Wireless Routing, Smart Batching & Bypass-Safe Data!
Are you tired of looking at a canvas that resembles a bowl of spaghetti? Do your complex multi-channel KSampler workflows break or lose filename data when you bypass a node?
Meet TJ_NODE โ the ultimate custom node pack designed to bring absolute order, efficiency, and safety to your ComfyUI workspace.
๐ Get it on GitHub Here! (Currently pending approval on ComfyUI Manager! Be an early adopter and install manuallyโinstructions below!)
# โจ TJ_NODE v2.0.1 UPDATE!!
Kill Your Spaghetti Wires in ComfyUI
## Advanced Wireless Workflow Architecture for ComfyUI
Your workflow is not complicated.
Your wires are.
TJ_NODE is a next-generation ComfyUI node package designed for creators who are tired of spaghetti-wire chaos.
Instead of dragging endless wires across giant workflows, TJ_NODE introduces a powerful Wireless Fake Wire Architecture that keeps your graph:
* Cleaner
* Modular
* Scalable
* Easier to debug
* Actually readable
---
# ๐ Why TJ_NODE Exists
As ComfyUI workflows become larger and more advanced, wire management becomes a nightmare.
You know the feeling:
* giant wire jungles
* impossible reroutes
* debugging hell
* wires crossing the entire canvas
* nodes becoming unreadable
TJ_NODE was built specifically to solve this problem.
# โก Core Concept
## โจ Invisible Fake Wire System
Traditional Workflow:
```text id="we11d"
Load Image โโโโโโโโโโโโโโโโโโโโโโโโโโ KSampler
```
TJ_NODE Workflow:
```text id="w11ad"
Load Image
โ Set
โ Get
โ KSampler
```
The actual graph connection still exists internally.
But visually?
The wire disappears.
Your workflow instantly becomes dramatically cleaner.
# โจ Main Features
## ๐ง Wireless Fake Wire Architecture
* Invisible workflow routing
* Clean large-scale pipelines
* Real internal graph linking
* Modular workflow design
* Reduced wire clutter
---
## โก Embedded Get System
Get functionality can be embedded directly into normal nodes.
No need to place endless standalone Get nodes everywhere.
Supported Nodes:
* Smart Show (TJ)
* Save & Preview Image (TJ)
* Prompt Text (TJ)
* Batch to Multi Image Output (TJ)
## ๐ Realtime Hover Wire Preview
Invisible wires can be previewed dynamically on hover.
Clean while working.
Visible while debugging.
```text id="sff22"
TJ Node
โ Realtime Wires View Mode
```
## ๐ Eclipse Compatibility
TJ_NODE fully supports Eclipse SetNodes.
Eclipse providers can be received directly from TJ Get systems.
Perfect for:
* Eclipse workflows
* massive routing systems
* advanced production pipelines
## ๐ Advanced Workflow Utilities
Included Systems:
* Set Node (TJ)
* Get Node (TJ)
* Multi Get Node (TJ)
* Multi Router (TJ)
* Dynamic Image Batch (TJ)
* Multi Image Loader (TJ)
* Smart Show (TJ)
* Save & Preview Image (TJ)
* Prompt Text (TJ)
* Text Concatenate (TJ)
* Batch to Multi Image Output (TJ)
# ๐ฅ Built For Large Workflows
TJ_NODE is not just another utility node pack.
It is a workflow architecture toolkit designed for:
* Large ComfyUI pipelines
* Professional workflow organization
* Advanced AI creators
* Eclipse users
* Massive image systems
* Debug-heavy workflows
* Clean UI lovers
# โจ What Makes TJ_NODE Different
Most node packs add more nodes.
TJ_NODE changes how workflows are structured.
This is not just:
> "more utility nodes"
This is:
> workflow infrastructure
---
# โก Key Advantages
โ Cleaner workflows<br>
โ Reduced spaghetti wires<br>
โ Faster debugging<br>
โ Better scalability<br>
โ Embedded wireless systems<br>
โ Eclipse compatibility<br>
โ Dynamic provider architecture<br>
โ Ghost wire cleanup<br>
โ Hidden wire rebuilding<br>
โ Professional workflow organization<br>
# ๐งฉ Workflow Philosophy
TJ_NODE treats ComfyUI like a real modular architecture system.
The goal is simple:
> Build workflows that stay clean even after they become massive.
# โจ Created by TJ
Feedback, ideas, and bug reports are always welcome.
Letโs evolve ComfyUI workflows together.
๐ฅ What's New in v0.22? The "Wireless" Revolution!
We've completely overhauled how you connect nodes. Say goodbye to messy cables crisscrossing your screen.
๐ช Invisible Wires (Set / Get / Multi Get Nodes): We've introduced a wireless paradigm! Use a
Set Nodeto broadcast your data, and use aGet Node(orMulti Get Node) anywhere on your canvas to receive it via a simple dropdown menu. The connecting wires become invisible, giving you a beautiful, clean canvas.๐๏ธ Multi Router with "Auto Set": Our new Multi Router can handle up to 20 inputs/outputs dynamically. Turn on the
Auto Settoggle, and every single output port automatically becomes an independent Set Node broadcasting its data!๐ฑ๏ธ Smart Global Context Menu: Right-click anywhere for pure magic!
Instantly
Show/Hide Wiresfor specific connections.Click
Go to Sourceon any Get node to instantly jump across the canvas to where the data is coming from.Use the Convert ALL Inputs/Outputs to Set/Get button to instantly untangle any giant node with one click.
๐จ Fixed UI & Top-Tier Sorting: TJ Nodes now exclusively feature a sleek Purple & Black brand color and are forcibly sorted to the very top of your Add Node menu (
0. ๐ฃ TJ Nodes) so you never have to hunt for them again.

https://github.com/user-attachments/assets/e084d5c4-3edc-44fb-b78d-e1d57fdef77e)
๐ Core Features That Will Save Your Life
๐ก๏ธ Bypass-Safe Architecture
Ever bypassed an intermediate node only to have your whole pipeline output errors or break? TJ_Nodes are built to be bypass-safe. Even if a node passes a None value, the workflow won't stop. It intelligently collects only valid data. If everything is bypassed, it safely outputs a black screen instead of an error.
โ Dynamic Expanding Inputs
No more fixed input slots. When using our Dynamic Batch nodes, connecting a wire automatically spawns the next input pin (image_2, files_2, etc.). Disconnect a wire, and the UI cleans itself up automatically. It even supports wildcard (*) matching to prevent connection errors!
๐ Advanced Save & Path Tracking (Eclipse Integrated)
If you use ComfyUI_Eclipse, you know it generates complex regex-based filenames and date folders. TJ_Nodes perfectly trace these back in memory!
Custom Paths: Leave the path blank to save in the original folder, or use relative paths like
..\or\upscaleto dynamically create sub/parent folders on the fly.100% Quality Output: Choose to keep original extensions or convert to PNG/JPG/WebP at guaranteed maximum lossless quality.

https://github.com/user-attachments/assets/ce20c91c-9129-402c-b910-4939250c6da2)
๐ ๏ธ The Ultimate Utility Nodes
๐ผ๏ธ Multi Image Loader (TJ)
An all-in-one image manager directly inside your node.
URL Download: Paste a link and download directly to your ComfyUI input folder!
Built-in File Browser: Switch between Input/Output/Download folders, multi-select, and Drag & Drop files from your PC directly into the node.
Auto-Resizing: Load images of different sizes? No problem. It automatically resizes them to match the first image (or by Megapixel budget) and outputs a perfect batch tensor.
<div style="display:flex; gap:10px;"> <img width="48%" src="https://github.com/user-attachments/assets/51311568-aa6d-471e-82e2-de01b8939aaf" /> <img width="48%" src="https://github.com/user-attachments/assets/100c923b-5d12-4407-b3f1-b1f2faf8f7fe" /> </div>
โ๏ธ Batch to Multi Image Output (TJ)
Need to process images individually after a batch load? This node splits a batch tensor into up to 64 individual IMAGE slots. Perfect for routing different images to different KSamplers simultaneously!

https://github.com/user-attachments/assets/1aa30408-18b0-4943-bbd0-99bc2d2c233b
โณ How to Install (Early Access!)
We are currently sitting in the queue waiting for approval on the official ComfyUI Manager. ๐ญ
But you don't have to wait! Getting it manually is super easy:
Method 1: Using Git (Recommended)
Open your terminal/command prompt.
Navigate to your ComfyUI custom nodes folder:
cd ComfyUI/custom_nodes/Clone the repo:
git clone https://github.com/YOUR_GITHUB_USERNAME/comfyui-TJ_Node.git(Make sure to replace with your actual repo link!)Restart ComfyUI.
Method 2: Manual ZIP Download
Go to the GitHub Repository.
Click the green
<> Codebutton and select Download ZIP.Extract the ZIP file.
Rename the extracted folder to
comfyui-TJ_Nodeand place it inside yourComfyUI/custom_nodes/directory.Restart ComfyUI and look for
โจ TJ Nodesin your menu!
Description
# โจ TJ_NODE v1.0
## Large Scale Wireless Workflow Architecture Toolkit for ComfyUI
ComfyUI์ฉ ๋๊ท๋ชจ Wireless Workflow Architecture Toolkit
Large Scale Wireless Workflow Architecture Toolkit for ComfyUI
---
TJ_NODE๋ ๋จ์ Utility Node Pack์ด ์๋๋๋ค.
TJ_NODE is not just another utility node pack.
TJ_NODE๋ ๋๊ท๋ชจ ComfyUI Workflow๋ฅผ ์ ์ง ๊ฐ๋ฅํ ๊ตฌ์กฐ๋ก ๋ง๋ค๊ธฐ ์ํ Architecture Toolkit์ ๋๋ค.
TJ_NODE is an architecture toolkit designed to make large-scale ComfyUI workflows maintainable.
# โจ Overview
TJ_NODE๋ ๋ณต์กํ ComfyUI Workflow๋ฅผ ๋ ์ฝ๊ธฐ ์ฝ๊ณ , ์ ์ง ๊ฐ๋ฅํ๋ฉฐ, ๊ตฌ์กฐ์ ์ผ๋ก ์ด์ํ๊ธฐ ์ํด ์ค๊ณ๋์์ต๋๋ค.
TJ_NODE was designed to make complex ComfyUI workflows cleaner, more maintainable, and structurally scalable.
TJ_NODE์ ํต์ฌ์ ๋จ์ํ ๋ ธ๋ ์ถ๊ฐ๊ฐ ์๋๋๋ค.
TJ_NODE is not simply about adding more nodes.
ํต์ฌ์ Workflow Architecture์ ๋๋ค.
The core idea is Workflow Architecture.
---
๊ธฐ์กด ComfyUI Workflow๊ฐ ์ปค์ง์๋ก ๋ค์ ๋ฌธ์ ๊ฐ ๋ฐ์ํฉ๋๋ค.
As ComfyUI workflows become larger, the following problems quickly appear.
* Giant Visible Wires
* Routing Chaos
* Preview Clutter
* Save Structure Collapse
* Reload Instability
* Workflow Maintenance Difficulty
---
TJ_NODE๋ ์ด๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ๋ค์ ์์คํ ์ ์ ๊ณตํฉ๋๋ค.
TJ_NODE introduces the following systems to solve these problems.
* Wireless Fake-Wire Architecture
* Embedded Get System
* Multi Router Workflow Structure
* Batch Workflow System
* Preview Lifecycle System
* Save Pipeline Architecture
* HTML5 Overlay UI System
* Reload-Safe Wireless Lifecycle
# โจ Why TJ_NODE Exists
TJ_NODE์ ๋ชฉํ๋ ๋จ์ํ Workflow๋ฅผ ์๋์ํค๋ ๊ฒ์ด ์๋๋๋ค.
TJ_NODE is NOT about simply making workflows work.
TJ_NODE์ ๋ชฉํ๋ ๋๊ท๋ชจ Workflow๋ฅผ ์ ์ง ๊ฐ๋ฅํ ์ํ๋ก ๋ง๋๋ ๊ฒ์ ๋๋ค.
TJ_NODE is about making large-scale workflows maintainable.
---
ํต์ฌ ์ฒ ํ:
Core Philosophy:
```text id="bw9q4y"
Large Scale Workflow Architecture
```
---
TJ Workflow์ ํต์ฌ์ ๋ค์ ๊ตฌ์กฐ์ ๋๋ค.
The core of TJ Workflow is section-based architecture.
```text id="pfuk8o"
INPUT
โ
GENERATION
โ
EDIT
โ
UPSCALE
โ
PREVIEW
โ
SAVE
```
---
๊ฐ Section ๋ด๋ถ๋ ์งง์ Wire๋ฅผ ์ฌ์ฉํฉ๋๋ค.
Short wires are used inside each section.
Section ๊ฐ ์ฐ๊ฒฐ์ Wireless Routing์ ์ฌ์ฉํฉ๋๋ค.
Wireless routing is used between sections.
---
#์คํฌ๋ฆฐ์ท : SECTION ARCHITECTURE
---
# ๐ v1.0 Major Features
| Feature | Description |
| ------------------------- | ------------------------------ |
| Wireless Fake-Wire System | ์จ๊ฒจ์ง Wireless Routing ์์คํ |
| Embedded Get System | ์ผ๋ฐ ๋ ธ๋ ๋ด๋ถ Wireless Receive |
| Multi Router Architecture | Section ๊ธฐ๋ฐ Workflow ๋ถ๋ฆฌ |
| Realtime Hover Wire | Hover ๊ธฐ๋ฐ Hidden Wire ํ์ |
| Preview Lifecycle | Reload-safe Preview Restore |
| Save Pipeline System | ๊ตฌ์กฐ์ Save Chain Architecture |
| Batch Workflow System | Dynamic Batch & Routing |
| Eclipse Bridge | Eclipse Workflow Compatibility |
| HTML5 Overlay UI | Advanced Interactive UI Layer |
| Reload-Safe Lifecycle | Provider Reconnect & Restore |
# โจ Wireless Workflow Architecture
TJ_NODE์ ํต์ฌ์ Wireless Workflow Architecture์ ๋๋ค.
The core of TJ_NODE is Wireless Workflow Architecture.
TJ_NODE๋ ๊ธด Visible Wire ๋์ Fake-Wire ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํฉ๋๋ค.
TJ_NODE replaces massive visible wires using Fake-Wire architecture.
---
๊ธฐ์กด ๋ฐฉ์:
Traditional Workflow:
```text id="iw01r0"
Load Image
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ KSampler
```
---
TJ Workflow ๋ฐฉ์:
TJ Workflow Style:
```text id="s8j7df"
Load Image
โ Set Node
KSampler
โ Get Node
```
---
์ค์ ์ฐ๊ฒฐ์ ์ ์ง๋์ง๋ง ์๊ฐ์ ์ผ๋ก๋ ์จ๊ฒจ์ง๋๋ค.
The logical connection remains intact while being visually hidden.
์ด๋ฅผ ํตํด:
This allows:
* Cleaner Workflow
* Better Readability
* Easier Maintenance
* Section Modularization
* Reduced Wire Clutter
# โจ Embedded Get System
TJ_NODE์ ํต์ฌ ๊ธฐ๋ฅ ์ค ํ๋๋ Embedded Get System์ ๋๋ค.
One of TJ_NODE's core features is the Embedded Get System.
์ด์ ๋ณ๋์ Get Node๋ฅผ ๋ฐ๋ณต ๋ฐฐ์นํ ํ์ ์์ด ์ผ๋ฐ ๋ ธ๋ ๋ด๋ถ์์ ์ง์ Wireless Receive ๊ฐ๋ฅํฉ๋๋ค.
Data can now be received directly inside nodes without placing standalone Get nodes everywhere.
---
์ง์ ๋ ธ๋:
Supported Nodes:
* Save & Preview Image (TJ)
* Save & Preview Video (TJ)
* Smart Show (TJ)
* Prompt Text (TJ)
* Batch to Multi Image Output (TJ)
---
์ฅ์ :
Benefits:
* Reduced Node Count
* Cleaner Workflow
* Local Wireless Receive
* Better Workflow Readability
* Easier Maintenance
# โจ Multi Router Architecture
Multi Router๋ TJ Workflow Architecture์ ํต์ฌ ๋ ธ๋์ ๋๋ค.
Multi Router is one of the most important nodes in TJ Workflow Architecture.
---
ํต์ฌ ์ญํ :
Core Roles:
* Workflow Branch Separation
* Section Modularization
* Auto Set Provider Generation
* Wireless Branch Routing
---
์ถ์ฒ ๊ตฌ์กฐ:
Recommended Structure:
```text id="32q76m"
Generation
โ
Multi Router
โโ Preview
โโ Upscale
โโ Compare
โโ Save
```
---
Auto Set ON ์ ๊ฐ Output์ ์๋ Wireless Provider๊ฐ ๋ฉ๋๋ค.
When Auto Set is enabled, each output automatically becomes a wireless provider.
# ๐ Wireless Routing System
TJ_NODE์ ํต์ฌ ์์คํ ์ ๋๋ค.
This is the core system of TJ_NODE.
TJ Workflow Architecture์ ์ค์ฌ ์ญํ ์ ์ํํฉ๋๋ค.
It acts as the foundation of TJ Workflow Architecture.
---
## โจ Set Node (TJ)
Wireless Provider ์์ฑ ๋ ธ๋์ ๋๋ค.
Wireless Provider creation node.
Workflow ๋ด๋ถ์์ ๋ฐ์ดํฐ๋ฅผ ๋ฌด์ ์ผ๋ก ์ก์ ํ๊ธฐ ์ํ Provider ์ญํ ์ ์ํํฉ๋๋ค.
Acts as a wireless provider for transmitting workflow data.
---
ํต์ฌ ๊ธฐ๋ฅ:
Core Features:
* Wireless Provider Registration
* Fake-Wire Routing
* Reload-safe Provider Restore
* Dynamic Provider Lifecycle
---
์ถ์ฒ ์ฌ์ฉ:
Recommended Usage:
* IMAGE Routing
* Prompt Routing
* Model Routing
* Section Architecture
## โจ Get Node (TJ)
Wireless Receive ๋ ธ๋์ ๋๋ค.
Wireless receive node.
Set Node์ Provider๋ฅผ ์์ ํ์ฌ ๊ธด Visible Wire ์์ด ๋ฐ์ดํฐ๋ฅผ ๋ฐ์ ์ ์์ต๋๋ค.
Receives providers from Set Nodes without long visible wires.
---
ํต์ฌ ๊ธฐ๋ฅ:
Core Features:
* Wireless Receive
* Fake-Wire Connection
* Hover Wire Preview
* Eclipse Provider Compatibility
## โจ Multi Get Node (TJ)
์ฌ๋ฌ Wireless Provider๋ฅผ ๋์์ ์์ ํ๋ ํตํฉ Receive ๋ ธ๋์ ๋๋ค.
Integrated receiver node for multiple wireless providers.
๋๊ท๋ชจ Workflow Module ๊ตฌ์ฑ์ ๋งค์ฐ ์ค์ํฉ๋๋ค.
Very important for large-scale workflow modularization.
---
์ง์ ๊ธฐ๋ฅ:
Features:
* Multiple Provider Receive
* Reorder UI
* Compact Slot Structure
* Module Architecture
## โจ Multi Router (TJ)
TJ Workflow Architecture์ ํต์ฌ Branch ์์คํ ์ ๋๋ค.
Core branching system of TJ Workflow Architecture.
Workflow๋ฅผ Section ๊ธฐ๋ฐ์ผ๋ก ๋ถ๋ฆฌํ๊ธฐ ์ํด ์ฌ์ฉ๋ฉ๋๋ค.
Used to separate workflows into modular sections.
---
ํต์ฌ ๊ธฐ๋ฅ:
Core Features:
* Workflow Branch Separation
* Auto Set Provider Generation
* Wireless Branch Routing
* Section Modularization
# ๐ Batch Workflow System
TJ_NODE์ Batch Workflow System์ ๋จ์ Batch ์ฒ๋ฆฌ ๋ ธ๋ ๋ชจ์์ด ์๋๋๋ค.
TJ_NODE's Batch Workflow System is not just a collection of batch utility nodes.
๋๊ท๋ชจ Workflow๋ฅผ ๊ตฌ์กฐ์ ์ผ๋ก ์ด์ํ๊ธฐ ์ํ Architecture Layer์ ๋๋ค.
It is an architecture layer designed for structurally managing large-scale workflows.
---
์ง์ ๊ธฐ๋ฅ:
Core Features:
* Dynamic Batch Processing
* Resolution Normalize
* Metadata Preservation
* Drag Reorder
* Thumbnail Grid
* Auto Set Routing
* Eclipse Metadata Sync
## โจ Multi Image Loader (TJ)
TJ Workflow์ ํต์ฌ ์ ๋ ฅ ํ๋ธ์ ๋๋ค.
Core input hub of TJ Workflow.
๋จ์ ์ด๋ฏธ์ง ๋ก๋๊ฐ ์๋๋ผ:
It is not just an image loader.
* Image Stack Manager
* Batch Generator
* Resolution Manager
* Metadata Sync System
* Wireless Provider Source
์ญํ ์ ๋์์ ์ํํฉ๋๋ค.
It simultaneously acts as all of the above systems.
---
ํต์ฌ ๊ธฐ๋ฅ:
Core Features:
* Drag & Drop Image Load
* Thumbnail Grid
* URL Download
* Drag Reorder
* Resolution Normalize
* Batch Tensor Generation
* Auto Set Provider
---
์ง์ Resize ๋ชจ๋:
Supported Resize Modes:
* None
* Long Edge
* Short Edge
* Custom
* Megapixel
---
Auto Set ํ์ฑํ ์ ๋ค์ Provider๋ฅผ ์๋ ์์ฑํฉ๋๋ค.
When Auto Set is enabled, the following providers are automatically generated.
```text id="8i0h4l"
TJ / BATCH
TJ / WIDTH
TJ / HEIGHT
```
---
์ถ์ฒ ์ฌ์ฉ:
Recommended Usage:
* Dataset Workflow
* Image Generation Pipeline
* ControlNet Batch
* Style Transfer Workflow
* Multi Image Compare
* Large Batch Processing
## โจ Dynamic Image Batch (TJ)
๋์ IMAGE Batch ์์ฑ ๋ ธ๋์ ๋๋ค.
Dynamic IMAGE batch generation node.
Workflow ์ํ์ ๋ฐ๋ผ ์ ๋์ ์ผ๋ก Batch๋ฅผ ๊ตฌ์ฑํ ์ ์์ต๋๋ค.
Allows workflows to dynamically construct image batches.
---
ํต์ฌ ๊ธฐ๋ฅ:
Core Features:
* Dynamic Batch Generation
* Image Grouping
* Workflow Distribution
* Batch Scaling
---
์ถ์ฒ ์ฌ์ฉ:
Recommended Usage:
* Image Variation Workflow
* Multi Prompt Generation
* Iterative Processing
* Grouped Upscale Pipeline
## โจ Dynamic Image Batch (Eclipse-TJ)
Eclipse Workflow์ ํธํ๋๋ Metadata ๊ธฐ๋ฐ Batch ์์คํ ์ ๋๋ค.
Metadata-aware batch system compatible with Eclipse workflows.
---
ํต์ฌ ๊ธฐ๋ฅ:
Core Features:
* IMAGE + FILES Pair Sync
* Original File Metadata
* Original Path Tracking
* Eclipse Save Sync
* Metadata Preservation
---
์ผ๋ฐ Batch ์์คํ ๊ณผ ๋ฌ๋ฆฌ ์๋ณธ ํ์ผ ๊ตฌ์กฐ๋ฅผ ์ ์งํฉ๋๋ค.
Unlike normal batch systems, original file structures are preserved.
---
์ถ์ฒ ์ฌ์ฉ:
Recommended Usage:
* Large Dataset Workflow
* Eclipse Workflow
* Metadata-based Pipeline
* Original Path Tracking
## โจ Batch to Multi Image Output (TJ)
IMAGE Batch๋ฅผ ์ต๋ 64๊ฐ์ IMAGE Output์ผ๋ก ๋ถ๋ฆฌํฉ๋๋ค.
Splits IMAGE batches into up to 64 IMAGE outputs.
---
ํต์ฌ ๊ธฐ๋ฅ:
Core Features:
* Batch Split
* Multi Branch Workflow
* Individual Image Routing
* Embedded Get Support
---
์ถ์ฒ ์ฌ์ฉ:
Recommended Usage:
* Selective Upscale
* Compare Workflow
* Multi Save Pipeline
* Branch Processing
* Image Ranking
# ๐ Preview / Utility System
TJ Preview System์ ๋จ์ Preview Node๊ฐ ์๋๋๋ค.
TJ Preview System is not just another preview node system.
TJ Workflow์ Visualization & Inspection Layer ์ญํ ์ ์ํํฉ๋๋ค.
It acts as the visualization and inspection layer of TJ Workflow.
---
์ง์ ๊ธฐ๋ฅ:
Core Features:
* Fullscreen Preview
* Snapshot System
* Batch Viewer
* Reload Restore
* HTML5 Video Playback
* Audio Controller
* Interactive Overlay UI
## โจ Save & Preview Image (TJ)
์ด๋ฏธ์ง ์ ์ฅ๊ณผ Preview๋ฅผ ํตํฉํ Unified Preview Node์ ๋๋ค.
Unified preview node combining image saving and preview systems.
---
ํต์ฌ ๊ธฐ๋ฅ:
Core Features:
* In-node Preview
* Fullscreen Viewer
* Smart Grid
* Snapshot Preview
* Keyboard Navigation
* Embedded Get
* Save Pipeline Support
---
์ง์ ๊ธฐ๋ฅ:
Supported Features:
| Feature | Description |
| ----------------- | ------------------------- |
| Fullscreen Viewer | ํ๋ ์ด๋ฏธ์ง ๊ฒ์ฌ |
| Smart Grid | Batch Grid Preview |
| Snapshot System | Preview Checkpoint |
| Keyboard Control | โ โ ESC Navigation |
| Embedded Get | Wireless Receive |
| Reload Restore | Preview Lifecycle Restore |
---
์ถ์ฒ ์ฌ์ฉ:
Recommended Usage:
* Generation Preview
* Upscale Compare
* Final Output Inspection
* Workflow Checkpoint
## โจ Save & Preview Video (TJ)
Video Workflow์ฉ ํตํฉ Preview ์์คํ ์ ๋๋ค.
Integrated preview system for video workflows.
---
ํต์ฌ ๊ธฐ๋ฅ:
Core Features:
* IMAGE Batch Playback
* Video Decode
* Audio Mux
* HTML5 Video Player
* Audio Controller
* Reload-safe Preview Restore
---
์ง์ ๊ธฐ๋ฅ:
Supported Features:
* MP4 Decode
* Frame Preview
* Audio Only Mode
* Dual Audio Controller
* Playback Restore
* Video Snapshot
---
์ถ์ฒ ์ฌ์ฉ:
Recommended Usage:
* Animation Workflow
* VFI Pipeline
* Frame Inspection
* Video Preview
* Audio Sync Workflow
## โจ Smart Show (TJ)
TJ_NODE์ Universal Debug Viewer์ ๋๋ค.
Universal debug viewer of TJ_NODE.
---
์๋์ผ๋ก ๋ฐ์ดํฐ ํ์ ์ ๋ถ์ํ๊ณ ํ์ํฉ๋๋ค.
Automatically detects and visualizes workflow data types.
์ง์ ํ์ :
Supported Types:
* IMAGE
* STRING
* FLOAT
* INT
* JSON
* LIST
* VIDEO
* AUDIO
---
ํต์ฌ ๊ธฐ๋ฅ:
Core Features:
* Automatic Type Detection
* Text Viewer
* Media Viewer
* JSON Inspector
* Wireless Receive
* Embedded Get
---
์ถ์ฒ ์ฌ์ฉ:
Recommended Usage:
* Workflow Debug
* Metadata Inspect
* Prompt Inspect
* JSON Visualization
* Audio/Video Check
## โจ Prompt Text (TJ)
Workflow์ฉ Modular Prompt Architecture Node์ ๋๋ค.
Modular prompt architecture node for workflows.
---
๊ธด Text Wire ์์ด Prompt๋ฅผ ๊ตฌ์กฐ์ ์ผ๋ก ๊ด๋ฆฌํ ์ ์์ต๋๋ค.
Allows structured prompt management without giant text wires.
---
ํต์ฌ ๊ธฐ๋ฅ:
Core Features:
* Embedded Get
* Prompt Reuse
* Wireless Prompt Routing
* Prompt Block Architecture
---
์ถ์ฒ ์ฌ์ฉ:
Recommended Usage:
* Character Prompt
* Style Prompt
* Camera Prompt
* Lighting Prompt
* Reusable Prompt Blocks
## โจ Text Concatenate (TJ)
Dynamic Text Combine Node์ ๋๋ค.
Dynamic text combination node.
---
์ฌ๋ฌ Prompt Block์ ๊ฒฐํฉํ์ฌ ์ต์ข Prompt๋ฅผ ์์ฑํฉ๋๋ค.
Combines multiple prompt blocks into final prompts.
---
ํต์ฌ ๊ธฐ๋ฅ:
Core Features:
* Dynamic Inputs
* Custom Delimiter
* Multi Prompt Merge
* Scalable Text Combine
---
์ถ์ฒ ์ฌ์ฉ:
Recommended Usage:
* Character + Style Prompt
* Camera + Lighting Prompt
* Modular Prompt Pipeline
* Prompt Layer Architecture
---
## โจ Show Any (TJ)
Lightweight universal workflow inspection node.
๊ฒฝ๋ Universal Workflow Inspect Node์ ๋๋ค.
---
Show Any๋ ๋ค์ํ ํ์ ์ ๋ฐ์ดํฐ๋ฅผ ์์ ํ๊ฒ ํผ์ณ์ ํ์ํ๋ฉด์ ์๋ณธ ๊ฐ์ ๊ทธ๋๋ก ํต๊ณผ์ํค๋ Debug / Monitor Node์ ๋๋ค.
Show Any safely visualizes workflow data while preserving the original passthrough output.
---
์ง์ ํ์ :
Supported Types:
* STRING
* INT / FLOAT
* LIST
* JSON / DICT
* TENSOR
* PYTHON OBJECT
---
ํต์ฌ ๊ธฐ๋ฅ:
Core Features:
* Universal ANY Input
* Original Passthrough Output
* Tensor Summary
* JSON-safe Display
* Copy Button
* Embedded Get
* Wireless Provider Support
---
์ถ์ฒ ์ฌ์ฉ:
Recommended Usage:
* Workflow Debug
* Tensor Inspection
* Metadata Visualization
* Wireless Provider Inspect
* Smart Converter Status Check
## โจ Smart Converter (TJ)
Universal Type Conversion Node์ ๋๋ค.
Universal type conversion utility node.
---
ANY ์ ๋ ฅ์ ๋ค์ํ ํ์ ์ผ๋ก ์์ ํ๊ฒ ๋ณํํฉ๋๋ค.
Safely converts ANY input into multiple workflow data types.
---
์ง์ ํ์ :
Supported Types:
* AUTO
* INT
* FLOAT
* STRING
* BOOLEAN
* TENSOR
* LIST
* DICT
* JSON
---
ํต์ฌ ๊ธฐ๋ฅ:
Core Features:
* Dynamic Output Type
* Status Output
* Strict Mode
* Embedded Get
* Wireless Conversion Workflow
---
strict_mode OFF ์ํ์์๋ ๋ณํ ์คํจ ์ ๊ธฐ๋ณธ๊ฐ๊ณผ WARN status๋ฅผ ๋ฐํํฉ๋๋ค.
When strict_mode is OFF, conversion failures return fallback values with WARN status output.
---
์ถ์ฒ ์ฌ์ฉ:
Recommended Usage:
* String โ Number Conversion
* Tensor Scalar Conversion
* Metadata โ JSON
* Wireless Type Correction
* Boolean Workflow Control
## โจ Shortcut Launcher (TJ)
Workflow ๋ด๋ถ์์ ํด๋, ํ์ผ, URL์ ์ฆ์ ์คํํ๋ Utility Launcher Node์ ๋๋ค.
Utility launcher node for opening folders, files, and URLs directly inside workflows.
---
ํต์ฌ ๊ธฐ๋ฅ:
Core Features:
* Multi Shortcut Buttons
* Folder / File Launch
* URL Launch
* JSON Export / Import
* Color Preset
* Tooltip Support
* Settings Modal
---
์ถ์ฒ ์ฌ์ฉ:
Recommended Usage:
* Output Folder Launch
* Custom Node Folder
* GitHub Repository
* Civitai Upload Page
* Workflow Asset Folder
* Documentation Shortcut
## โจ VHS Hotkey Remote (Utility Extension)
TJ VHS Hotkey Remote๋ ์ผ๋ฐ ๋ ธ๋๊ฐ ์๋๋๋ค.
TJ VHS Hotkey Remote is NOT a standard node.
---
VideoHelperSuite(VHS) preview๋ฅผ ํค๋ณด๋ ๋จ์ถํค๋ก ์ง์ ์ ์ดํ๋ Global Utility Extension์ ๋๋ค.
A global utility extension for controlling VideoHelperSuite previews using keyboard shortcuts.
---
์ค์น ์์น:
Installation Path:
```text
ComfyUI/custom_nodes/ComfyUI-TJ_NODE/web/js/
```
ํ์ผ๋ช :
Filename:
```text
tj_vhs_hotkey_remote.js
```
---
์ง์ ๋จ์ถํค:
Supported Shortcuts:
| Shortcut | Function |
| --- | --- |
| Space | Pause / Play |
| Alt + H | Preview Hide |
| Alt + M | Mute |
| Alt + O | Open in Browser |
| Alt + S | Save Preview |
| Alt + C | Copy Original Path |
| Alt + Y | Sync Preview |
---
๋์ ๋ฐฉ์:
Behavior:
```text
Select VHS Preview Node
โ
Press Shortcut
โ
Instant Preview Control
```
---
์ถ์ฒ ์ฌ์ฉ:
Recommended Usage:
* Animation Inspection
* Frame Compare
* VFI Workflow
* Interpolation Workflow
* Rapid Preview Control
---
ํ์ ์์ผ๋ฉด ๋จ์ํ JS ํ์ผ๋ง ์ญ์ ํ๋ฉด ๋ฉ๋๋ค.
Can be removed simply by deleting the JS file.
# ๐ Save Pipeline System
TJ Save Pipeline์ ๋จ์ Save Node ๊ตฌ์กฐ๊ฐ ์๋๋๋ค.
TJ Save Pipeline is not just another save node structure.
Workflow ๊ฒฐ๊ณผ๋ฅผ ๊ตฌ์กฐ์ ์ผ๋ก ์ ์งํ๊ธฐ ์ํ Result Management Architecture์ ๋๋ค.
It is a result management architecture for structurally organizing workflow outputs.
## โจ Save Image (Primary-TJ)
TJ Save Pipeline์ ๊ธฐ์ค Save Node์ ๋๋ค.
Primary save node of TJ Save Pipeline.
---
ํต์ฌ ์ญํ :
Core Roles:
* Base Save Path Creation
* Save Context Generation
* Filename Structure Management
* Downstream Save Sync
---
์ง์ ๊ธฐ๋ฅ:
Core Features:
* Save Context Lifecycle
* Filename Prefix
* Collision Handling
* Metadata Save Structure
---
์ถ์ฒ ์ฌ์ฉ:
Recommended Usage:
* Main Result Save
* Generation Base Save
* Workflow Save Start Point
## โจ Save Image (Suffix-TJ)
Primary Save Context๋ฅผ ์ด์ด๋ฐ์ ํ์ ๊ฒฐ๊ณผ๋ฅผ ์ ์ฅํฉ๋๋ค.
Stores downstream results using inherited Primary Save Context.
---
ํต์ฌ ๊ธฐ๋ฅ:
Core Features:
* Suffix Save Chain
* Result Grouping
* Save Context Sync
* Filename Consistency
---
์ถ์ฒ ์ฌ์ฉ:
Recommended Usage:
* Upscale Result
* Detail Pass
* Compare Output
* Mask Save
* Workflow Variations
---
์์ ๊ตฌ์กฐ:
Example Structure:
```text id="abgwx3"
main.png
main_upscale.png
main_detail.png
main_compare.png
```
## โจ Save Image (Eclipse Suffix-TJ)
Eclipse Metadata ๊ธฐ๋ฐ Save Pipeline์ ๋๋ค.
Eclipse metadata-based save pipeline.
---
์๋ณธ ํ์ผ ๊ตฌ์กฐ๋ฅผ ์ ์งํ๋ฉด์ ํ์ ๊ฒฐ๊ณผ๋ฅผ ์ ์ฅํฉ๋๋ค.
Preserves original file structures while saving downstream results.
---
ํต์ฌ ๊ธฐ๋ฅ:
Core Features:
* Original Path Tracking
* Eclipse Metadata Sync
* Relative Path Restore
* Metadata Save Chain
---
์ถ์ฒ ์ฌ์ฉ:
Recommended Usage:
* Eclipse Workflow
* Dataset Pipeline
* Metadata Tracking Workflow
* Original Structure Preservation
# โจ Workflow Architecture Strategy
TJ_NODE์ ํต์ฌ์ ๋จ์ Node ๊ธฐ๋ฅ์ด ์๋๋๋ค.
The core of TJ_NODE is not individual node functionality.
ํต์ฌ์ Workflow Architecture์ ๋๋ค.
The real core is Workflow Architecture.
---
TJ Workflow์ ํต์ฌ ์ฒ ํ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
The core philosophy of TJ Workflow is:
```text id="0upn18"
Maintainable Workflow Architecture
```
---
TJ Workflow์์๋ ๋ค์ ๊ตฌ์กฐ๋ฅผ ๊ถ์ฅํฉ๋๋ค.
TJ Workflow recommends the following structure.
```text id="1wjlwm"
INPUT
โ
GENERATION
โ
EDIT
โ
UPSCALE
โ
PREVIEW
โ
SAVE
```
---
๊ฐ Section ๋ด๋ถ๋ ์งง์ Wire๋ฅผ ์ฌ์ฉํฉ๋๋ค.
Short wires are used inside each section.
Section ๊ฐ ์ฐ๊ฒฐ์ Wireless Routing์ ์ฌ์ฉํฉ๋๋ค.
Wireless routing is used between sections.
---
ํต์ฌ ๊ตฌ์กฐ:
Core Strategy:
```text id="y6i2ep"
Short Wires Inside Sections
Wireless Routing Between Sections
```
# โจ Recommended Workflow Design
TJ Workflow์์๋ ๋ค์ ์ ๋ต์ ์ถ์ฒํฉ๋๋ค.
TJ Workflow recommends the following workflow strategies.
---
## โ Recommended
### Embedded Get ์ ๊ทน ์ฌ์ฉ
Heavy usage of Embedded Get
๊ธด Visible Wire ๋์ Local Wireless Receive๋ฅผ ๊ถ์ฅํฉ๋๋ค.
Use local wireless receive instead of giant visible wires.
---
### Section Architecture ์ฌ์ฉ
Use Section Architecture
Workflow๋ฅผ ๊ธฐ๋ฅ ๋จ์๋ก ๋ถ๋ฆฌํ๋ ๊ฒ์ ๊ถ์ฅํฉ๋๋ค.
Split workflows into functional sections.
---
### Multi Router ์ค์ฌ ๊ตฌ์กฐ
Multi Router-centered Structure
Workflow Branch๋ฅผ ๊ตฌ์กฐ์ ์ผ๋ก ๋ถ๋ฆฌํฉ๋๋ค.
Structurally separate workflow branches.
---
### Save Chain ์ ์ง
Maintain Save Chain
Workflow ๊ฒฐ๊ณผ๋ฅผ ๊ทธ๋ฃน ๋จ์๋ก ์ ์งํฉ๋๋ค.
Keep workflow outputs grouped structurally.
---
### Stable Provider Naming ์ฌ์ฉ
Use Stable Provider Naming
Provider ์ด๋ฆ์ Routing Map ์ญํ ์ ์ํํฉ๋๋ค.
Provider names act as routing maps.
# โ Anti-Patterns
TJ Workflow์์๋ ๋ค์ ๊ตฌ์กฐ๋ฅผ ๋น์ถ์ฒํฉ๋๋ค.
TJ Workflow strongly discourages the following structures.
---
## Giant Visible Wire
Workflow ์ ์ฒด๋ฅผ ๊ฐ๋ก์ง๋ฅด๋ ๊ธด Wire ๊ตฌ์กฐ.
Massive visible wires crossing the entire workflow.
---
## Duplicate Provider Names
```text id="2h7uhs"
MAIN_IMAGE
MAIN_IMAGE
MAIN_IMAGE
```
์ค๋ณต Provider๋ Reconnect ๋ฌธ์ ๋ฅผ ๋ฐ์์ํต๋๋ค.
Duplicate providers can cause reconnect instability.
---
## Random Naming
```text id="t3f6u4"
test
aaa
temp
123
```
์๋ฏธ ์๋ ์ด๋ฆ์ Workflow ์ ์ง๋ณด์๋ฅผ ์ด๋ ต๊ฒ ๋ง๋ญ๋๋ค.
Meaningless naming makes workflow maintenance difficult.
---
## Random Save Structure
๋ฌด์์ Save Node ์ฌ์ฉ ๊ตฌ์กฐ.
Chaotic save node usage.
๊ฒฐ๊ณผ ์ถ์ ์ด ๊ฑฐ์ ๋ถ๊ฐ๋ฅํด์ง๋๋ค.
Makes result tracking extremely difficult.
---
## Giant Chaos Workflow
Section ๊ตฌ์กฐ ์์ด ๋ชจ๋ ๋ ธ๋๋ฅผ ํ๋์ ์์ญ์ ๋ฐฐ์นํ๋ ๋ฐฉ์.
Placing all nodes in one giant unstructured workflow.
# โจ Reload-Safe Workflow Architecture
TJ_NODE๋ Reload-safe Workflow๋ฅผ ๋งค์ฐ ์ค์ํ๊ฒ ์ค๊ณํฉ๋๋ค.
TJ_NODE is heavily designed around reload-safe workflow architecture.
---
์ง์ ๊ธฐ๋ฅ:
Core Features:
* Wireless Reconnect
* Provider Restore
* Fake-Wire Rebuild
* Preview Restore
* Save Context Restore
* Embedded Get Reconnect
---
์ถ์ฒ ์ ๋ต:
Recommended Strategy:
โ Stable Provider Naming
โ Auto Set Structure
โ Save Chain Consistency
โ Frequent Workflow Save
---
๋น์ถ์ฒ:
Avoid:
โ Random Provider Rename
โ Duplicate Providers
โ Unstable Dynamic Branches
# โจ Preview Lifecycle Architecture
TJ Preview๋ ๋จ์ Preview Node๊ฐ ์๋๋๋ค.
TJ Preview is not just a preview node system.
TJ Preview๋ Workflow Inspection Architecture์ ๋๋ค.
TJ Preview behaves as workflow inspection architecture.
---
๊ด๋ฆฌ๋๋ ์ํ:
Managed States:
* Preview Image
* Snapshot State
* Fullscreen State
* Grid Layout
* Reload Metadata
---
ํต์ฌ ๊ธฐ๋ฅ:
Core Features:
* Snapshot Preview
* Reload-safe Restore
* Batch Grid
* Fullscreen Viewer
* Video Playback
* Audio Controller
---
TJ Preview Copy๋ Live Mirror๊ฐ ์๋๋๋ค.
TJ Preview Copy is NOT a live mirror.
ํ์ฌ ์ํ๋ฅผ Snapshot ํํ๋ก ๋ณด์กดํฉ๋๋ค.
It preserves workflow states as snapshots.
---
์ถ์ฒ ์ฌ์ฉ:
Recommended Usage:
* Compare Workflow
* Workflow Checkpoints
* Result Tracking
* Debug Snapshot
* Before/After Comparison
# โจ Wireless Lifecycle System
TJ Wireless System์ ๋จ์ ์ฐ๊ฒฐ ์์คํ ์ด ์๋๋๋ค.
TJ Wireless System is not a simple connection system.
๋ด๋ถ์ ์ผ๋ก Wireless Lifecycle Architecture๋ฅผ ์ฌ์ฉํฉ๋๋ค.
Internally, it uses a Wireless Lifecycle Architecture.
---
๊ด๋ฆฌ ๊ธฐ๋ฅ:
Managed Systems:
* Provider Registry
* Wireless Reconnect
* Fake-Wire Sync
* Cleanup
* Reload Restore
* Dynamic Provider Refresh
---
Get Node์ Embedded Get๋ ๋์ผํ Lifecycle ์์์ ๋์ํฉ๋๋ค.
Get Nodes and Embedded Get run on the same wireless lifecycle system.
---
ํต์ฌ ๊ธฐ๋ฅ:
Core Features:
* Dynamic Provider Detection
* Invalid Provider Cleanup
* Ghost Wire Cleanup
* Hover Wire Sync
* Realtime Registry Refresh
# โจ Context Menu Features
TJ_NODE๋ ๋ค์ํ Workflow Utility Menu๋ฅผ ์ ๊ณตํฉ๋๋ค.
TJ_NODE provides various workflow utility menus.
---
์ง์ ๋ฉ๋ด:
Supported Menus:
```text id="j2vl0g"
TJ Node
โโ Refresh ALL Get Nodes
โโ Realtime Wires View Mode
โโ Show ALL Wires
โโ Properties
โโ Properties Panel
```
---
## Refresh ALL Get Nodes
Provider ๋ฆฌ์คํธ๋ฅผ ์ฌ๊ตฌ์ฑํฉ๋๋ค.
Rebuilds provider lists.
์ถ์ฒ ์ฌ์ฉ:
Recommended Usage:
* Provider Rename
* Reload Issues
* Eclipse Sync Problems
* Invalid Get List
---
## Realtime Wires View Mode
Hover ์์๋ง Hidden Wire๋ฅผ ํ์ํฉ๋๋ค.
Displays hidden wires only during hover.
---
์ถ์ฒ ์ค์ :
Recommended Setting:
```text id="kl8q5d"
Realtime Wires View Mode = ON
Show ALL Wires = OFF
```
---
์ด ์ค์ ์ด ๊ฐ์ฅ ์ฝ๊ธฐ ์ฌ์ด Workflow ์ํ๋ฅผ ์ ๊ณตํฉ๋๋ค.
This provides the cleanest workflow readability.
---
## Show ALL Wires
๋ชจ๋ Fake-Wire๋ฅผ ๊ฐ์ ๋ก ํ์ํฉ๋๋ค.
Forces all fake wires to become visible.
---
์ถ์ฒ ์ฌ์ฉ:
Recommended Usage:
* Wireless Debug
* Provider Trace
* Routing Inspection
* Workflow Repair
# โจ TJ_NODE Identity
TJ_NODE์ ๋ชจ๋ ๋ ธ๋๋ ํตํฉ๋ Visual Identity๋ฅผ ๊ณต์ ํฉ๋๋ค.
All TJ_NODE nodes share a unified visual identity.
---
๊ธฐ๋ณธ ํ ๋ง:
Default Theme:
```javascript id="3t6qt3"
node.bgcolor = "#000000";
node.color = "#7612DA";
node.title_text_color = "#FFFFFF";
```
---
Category ๊ตฌ์กฐ:
Category Structure:
```python id="n0jxll"
CATEGORY = " โจ TJ_Node/Wireless"
CATEGORY = " โจ TJ_Node/Batch"
CATEGORY = " โจ TJ_Node/Preview"
CATEGORY = " โจ TJ_Node/Utility"
CATEGORY = " โจ TJ_Node/Save"
CATEGORY = " โจ TJ_Node/Eclipse"
```
---
์ด ๊ตฌ์กฐ๋ Workflow ์์์ TJ_NODE ์์ญ์ ์ฆ์ ์๋ณํ ์ ์๊ฒ ํฉ๋๋ค.
This structure allows TJ_NODE workflows to be instantly recognizable.
# โจ Installation
## Install via ComfyUI Manager
```text id="ivn89r"
ComfyUI Manager
โ Install Custom Nodes
โ Search: TJ_NODE
```
---
## Manual Installation
```bash id="6i8v3g"
cd ComfyUI/custom_nodes
git clone https://github.com/designloves2/ComfyUI-TJ_NODE.git
```
---
์ค์น ํ ComfyUI๋ฅผ ์ฌ์์ํ์ธ์.
Restart ComfyUI after installation.
---
# โจ Documentation
TJ_NODE v1.0์ ์ ์ฒด ๊ณต์ ๋งค๋ด์ผ์ ํฌํจํฉ๋๋ค.
TJ_NODE v1.0 includes a complete official manual.
---
ํฌํจ ๋ด์ฉ:
Documentation Includes:
* Wireless Architecture
* Batch Workflow System
* Preview Lifecycle
* Save Pipeline
* Workflow Strategy
* Internal Systems
* Reload-safe Architecture
* Debug Guide
* Best Practices
* Anti-Patterns
---
์ถ์ฒ ๋ฌธ์:
Recommended Documentation:
```text id="e5vnh5"
TJ_NODE v1.0 MANUAL
# โจ Workflow Philosophy
TJ_NODE๋ ๋จ์ Utility Node Pack์ด ์๋๋๋ค.
TJ_NODE is not just another utility node pack.
TJ_NODE๋ Workflow Operating Architecture์ ๋๋ค.
TJ_NODE is a Workflow Operating Architecture.
---
TJ_NODE์ ํต์ฌ์ ์์ด์ด ์ ๊ฑฐ ์์ฒด๊ฐ ์๋๋๋ค.
TJ_NODE is NOT simply about hiding wires.
ํต์ฌ์ ๋๊ท๋ชจ Workflow๋ฅผ ์ค์ ์ด์ ๊ฐ๋ฅํ ์ํ๋ก ์ ์งํ๋ ๊ฒ์ ๋๋ค.
The real goal is keeping large-scale workflows maintainable and production-ready.
---
TJ Workflow์ ํต์ฌ ๊ฐ๋ :
Core Concept of TJ Workflow:
```text id="a4ujk7"
Large Scale Workflow Architecture
```
# โจ Credits
Created by TJ
ํผ๋๋ฐฑ๊ณผ ๋ฒ๊ทธ ์ ๋ณด๋ ์ธ์ ๋ ํ์ํฉ๋๋ค.
Feedback and bug reports are always welcome.

