Save 4 hours! We auto-setup your workflow! Free!

Drop your workflow.json — we handle every dependency, custom node, and model. Just open the link and run.

Auto-Setup Workflow Json (Free) Now!
ComfyUI > Nodes > OpenKatana > OpenKatana · Render composition

ComfyUI Node: OpenKatana · Render composition

Class Name

OpenKatana_render_composition

Category
OpenKatana/Tools
Author
rk0neki (Account age: 235days)
Extension
OpenKatana
Latest Updated
2026-11-05
Github Stars
0.05K

How to Install OpenKatana

Install this extension via the ComfyUI Manager by searching for OpenKatana
  • 1. Click the Manager button in the main menu
  • 2. Select Custom Nodes Manager button
  • 3. Enter OpenKatana in the search bar
After installation, click the Restart button to restart ComfyUI. Then, manually refresh your browser to clear the cache and access the updated list of nodes.

Visit ComfyUI Online for ready-to-use ComfyUI environment

  • Free trial available
  • 16GB VRAM to 80GB VRAM GPU machines
  • 400+ preloaded models/nodes
  • Freedom to upload custom models/nodes
  • 200+ ready-to-run workflows
  • 100% private workspace with up to 200GB storage
  • Dedicated Support

Run ComfyUI Online

OpenKatana · Render composition Description

Renders OpenKatana CSS compositions into numbered PNG frames and optional MP4 videos.

OpenKatana · Render composition:

OpenKatana_render_composition renders an OpenKatana CSS composition into a numbered sequence of PNG frames and, when video rendering is enabled, an MP4 video. It uses a browser-based rendering process to reproduce the composition’s layout, typography, components, and animation at each frame, making it useful for turning designed motion graphics into reusable media. The renderer also checks that selected frames remain identical when visited in reverse order and after the composition is mounted again, helping catch animations that depend on playback history rather than the intended frame. It records information about the rendering environment, source assets, layout measurements, and file fingerprints so you can investigate problems and track exactly what was rendered. This is a composition-rendering tool rather than an AI image generator or an interactive layer editor.

OpenKatana · Render composition Input Parameters:

project_id

A required STRING identifying the OpenKatana project in which the rendering tool should operate. The node passes this value into its argument-building process so the tool can work in the intended project context. Choose the project associated with your saved composition and its supporting assets; the supplied integration test uses demo as an example project identifier. This field selects the project context rather than defining the composition’s appearance or animation. The supplied node class does not specify a default value, minimum or maximum string length, or a list of allowed identifiers.

arguments

A required STRING containing the arguments used to call the rendering tool, normally supplied as a JSON object encoded as text. This is where you provide tool-specific details that are not exposed as separate node sockets. The supplied integration test calls render_composition with a project identifier and a path identifying the composition, so a basic argument object is {"path":"path/to/composition.json"}, with the example path replaced by the actual composition path in your project. Keep the JSON properly formatted, with double-quoted keys and string values. The underlying renderer supports canvas-size overrides and a video-generation switch, but the supplied node code does not show the complete tool argument schema, so their accepted tool-level names and availability cannot be guaranteed from this context alone. No default string, length limits, or fixed options are specified by the supplied node class.

after

An optional STRING accepted by the node’s execution method. In the supplied implementation, this value is not read, merged into the rendering arguments, or passed directly to the rendering tool. It therefore does not visibly configure the composition, frame size, or video encoding in this code. It may serve a workflow-level role elsewhere, but that behavior is not established by the provided implementation. You can leave it unconnected when you do not have a documented reason to use it. The execution method defaults to None when it is omitted; no string default, length limits, or allowed options are shown.

OpenKatana · Render composition Output Parameters:

result_json

A STRING containing the rendering tool’s response in JSON form, returned through the node’s response helper. Treat this as structured information about the render rather than an image tensor or a directly playable video socket. The supplied renderer returns a receipt containing a clip description with the project-relative frames_dir, the filename pattern of %05d.png, the frame count n, the frame rate fps, and the canvas dimensions w and h. For example, the pattern corresponds to filenames such as 00000.png and 00001.png. When video generation is enabled and succeeds, the receipt also includes the video location and its SHA-256 fingerprint, which identifies the resulting file’s contents. Additional receipt fields record the browser version, original and expanded composition fingerprints, input assets, runtime fingerprints, sampled determinism checks, layout measurements, font coverage, and lifecycle information. The renderer also writes composition.json, expanded.json, and receipt.json alongside the rendered assets. The exact outer JSON structure produced by the node’s response helper is not shown, so inspect the returned response before assuming these receipt fields are at its top level. The receipt reports credits_used as 0 and hosted_parity as not established; this does not establish equivalence with a hosted rendering service.

OpenKatana · Render composition Usage Tips:

  • Start with a saved composition that already belongs to the selected project. Use its actual path in arguments and keep the project identifier in project_id consistent with that location.
  • Use valid JSON in arguments, such as {"path":"path/to/composition.json"}. Do not add separate node inputs named width, height, or video; they are not part of this node’s exposed interface. Check the rendering tool’s argument schema before supplying additional JSON options.
  • Use even canvas dimensions when you need MP4 output, such as 1280 × 720 or 1920 × 1080. The underlying renderer rejects MP4 rendering if either dimension is odd. If an odd-sized canvas is essential, use PNG-only rendering through the tool’s supported video-disable option.
  • Keep canvas dimensions within the underlying renderer’s supported range of 16–7680 pixels per dimension, using whole numbers. The original composition canvas is used unless supported size overrides are supplied.
  • Test with a small canvas and a short animation before committing to a full-resolution render. Every frame is captured individually, and the renderer performs additional sampled captures for consistency checks, so larger frames and longer animations require more work.
  • Make animation depend on the requested frame rather than on elapsed browser time or previously played frames. Avoid unseeded randomness or persistent component state that changes the appearance after seeking or remounting.
  • Keep fonts, images, and other composition assets unchanged until rendering finishes. The renderer compares input information before and after capture and rejects a render if it detects changes.
  • Use the PNG sequence when you need individual frames for further compositing. Captures request a transparent background, but a composition with its own opaque background will still appear opaque; the provided code does not establish transparency support for the MP4 output.
  • Inspect the receipt when troubleshooting. Its sampled layout measurements, font-coverage information, browser version, and file fingerprints can help you identify asset or rendering differences. Measurements are collected at sampled frames, not at every frame.

OpenKatana · Render composition Common Errors and Solutions:

MP4 needs even dimensions; use PNG output for odd dimensions

  • Explanation: Video rendering is enabled, but the canvas width or height is an odd number. The renderer explicitly rejects this configuration before capturing the full sequence.
  • Solution: Change both canvas dimensions to even numbers, such as 1280 × 720. If you must preserve odd dimensions, disable video generation using the rendering tool’s supported argument and work with the PNG frames.

Component expansion is not deterministic

  • Explanation: The renderer expands the same composition twice and receives different results. Component expansion is the step that turns reusable components into the detailed composition the browser will display.
  • Solution: Check custom components and plugins for random values, time-dependent content, or changing external data during expansion. Make sure identical composition data always produces the same expanded layout and properties.

Composition is not deterministic when seeking backwards

  • Explanation: Selected frames look different depending on whether the renderer visits them in forward or reverse order. This usually indicates that appearance depends on playback history instead of the requested frame alone.
  • Solution: Review custom animation and component logic for accumulated changes, timers, or state that is not reset when seeking. Make each frame reproducible directly from its frame number and fixed composition data.

Composition differs after remount

  • Explanation: The renderer mounts the composition again and finds that sampled frames no longer match the earlier captures. Initialization or cleanup behavior may be leaving behind state or producing a different starting condition.
  • Solution: Ensure components initialize consistently and clean up timers, listeners, and persistent state when disposed. Replace time-dependent or random initialization with fixed, repeatable values.

Composition input changed during render

  • Explanation: The renderer detects a difference between its input-asset records before and after frame capture. One or more supporting files may have changed while the render was running.
  • Solution: Stop editing, replacing, or regenerating referenced assets during rendering. Finish saving fonts, images, and other dependencies first, then rerun the render with those files held unchanged.

unexpected inputs: …

  • Explanation: The node’s execution method raises this error when it receives extra named fields that are not declared in its accepted typed inputs. It is a node-call validation error, not an indication that the artwork itself is invalid.
  • Solution: Use only project_id, arguments, and optional after as the exposed node inputs. Put supported tool-specific settings inside arguments rather than inventing additional sockets or keyword fields.

Invalid JSON or unsupported arguments — exact message depends on the argument parser

  • Explanation: Malformed argument text or an unsupported option can prevent the tool call from being constructed or accepted. The supplied context does not include the parser’s exact error messages.
  • Solution: Check for missing commas, trailing commas, mismatched quotation marks, and unquoted property names. Start with a minimal object containing the composition path, then add only settings documented by the tool’s argument schema.

Width or height validation failure — exact message not shown

  • Explanation: The underlying composition opener requires each canvas dimension to be an integer from 16 to 7680. A value outside this range, or a non-integer value, fails validation.
  • Solution: Correct the saved composition’s canvas dimensions or any supported size overrides. For MP4 output, also make sure both values are even.

Composition, asset, or output file failure — exact message depends on the failing operation

  • Explanation: Rendering involves validating the composition, opening its dependencies, writing PNG frames and JSON files, and optionally encoding an MP4. Missing files, invalid composition data, unavailable dependencies, or filesystem problems can interrupt these steps; their exact error strings are not included in the supplied code.
  • Solution: Confirm that the composition exists in the intended project, its referenced assets are available, and the rendering process can write to the project’s output location. Check available disk space and use the detailed tool response to identify the failing file or operation. If PNG capture succeeds but video generation fails, check the encoding environment or use PNG-only output while resolving the video issue.

OpenKatana · Render composition Related Nodes

Go back to the extension to check out more related nodes.
OpenKatana
RunComfy
Copyright 2025 RunComfy. All Rights Reserved.

RunComfy is the premier ComfyUI platform, offering ComfyUI online environment and services, along with ComfyUI workflows featuring stunning visuals. RunComfy also provides AI Models, enabling artists to harness the latest AI tools to create incredible art.

OpenKatana · Render composition