ComfyMath-NG

ComfyMath-NG

ComfyMath-NG provides math and utility nodes for ComfyUI.

It is a maintained fork of the original ComfyMath project and preserves the existing node identifiers for compatibility with existing workflows.

The package currently registers 64 custom nodes under the math/... categories. Most operation nodes expose an op dropdown, allowing a single node to perform several related operations.

[!IMPORTANT] ComfyMath-NG is intended as a replacement for the original ComfyMath installation. Remove or disable the original ComfyMath package before installing ComfyMath-NG. Both packages register the same node identifiers and should not be enabled simultaneously.

Features

Provides nodes for:

• Boolean logic
• Integer, float, and generic number arithmetic
• Integer randomization with range constraints
• Numeric comparisons and conditions
• Conditional value selection and conditional arithmetic fallbacks
• Vec2, Vec3, and Vec4 arithmetic, scalar operations, and vector checks
• Type conversion and vector compose/breakout helpers
• SDXL preset and model-agnostic resolution helpers

Installation

Remove or disable the original ComfyMath installation before installing ComfyMath-NG.

From the custom_nodes directory in your ComfyUI installation, run:

git clone https://github.com/rabanti-github/ComfyMath.git ComfyMath-NG

Restart ComfyUI after installation. Nodes are displayed without the internal CM_ prefix.

Node Reference

Boolean Nodes

| Node | Purpose | Inputs | Outputs | | --- | --- | --- | --- | | BoolUnaryOperation | Applies a unary boolean operation. Operations: Not. | op, a: BOOLEAN | BOOLEAN | | BoolBinaryOperation | Applies a binary boolean operation. Operations: Nor, Xor, Nand, And, Xnor, Or, Eq, Neq. | op, a: BOOLEAN, b: BOOLEAN | BOOLEAN |

Boolean Operators

| Operator | Applicable for | Description | Exmaple | | --- | --- | --- | --- | | Not | BoolUnaryOperation | Inverts the input value. | Not True → False | | Nor | BoolBinaryOperation | True only when both inputs are false. | True Nor False → False | | Xor | BoolBinaryOperation | True when the inputs differ. | True Xor False → True | | Nand | BoolBinaryOperation | False only when both inputs are true. | True Nand True → False | | And | BoolBinaryOperation | True only when both inputs are true. | True And False → False | | Xnor | BoolBinaryOperation | True when the inputs are equal. | True Xnor True → True | | Or | BoolBinaryOperation | True when either input is true. | False Or True → True | | Eq | BoolBinaryOperation | Tests whether the inputs are equal. | True Eq False → False | | Neq | BoolBinaryOperation | Tests whether the inputs differ. | True Neq False → True |

Integer Nodes

| Node | Purpose | Inputs | Outputs | | --- | --- | --- | --- | | IntUnaryOperation | Applies a unary integer operation. Operations: Abs, Neg, Inc, Dec, Sqr, Cube, bitwise Not, Factorial. | op, a: INT | INT | | IntUnaryCondition | Tests one integer value. Conditions: zero/non-zero, positive/negative, even/odd. | op, a: INT | BOOLEAN | | IntBinaryOperation | Applies a binary integer operation. Operations include arithmetic, bitwise logic, shifts, Max, and Min. | op, a: INT, b: INT | INT | | IntBinaryCondition | Compares two integer values. Conditions: Eq, Neq, Gt, Lt, Geq, Leq. | op, a: INT, b: INT | BOOLEAN | | RandomInt | Returns a fixed, incremented, decremented, or randomized integer within a selected range constraint or custom limits. | value: INT, constraint, min: INT, max: INT, control_after_generation | INT | | IntUnaryOperationConditional | Applies a unary integer operation only when condition is true; otherwise returns a or fallback_value. | condition: BOOLEAN, fallback_mode, fallback_value: INT, op, a: INT | INT | | IntBinaryOperationConditional | Applies a binary integer operation only when condition is true; otherwise returns a, b, or fallback_value. | condition: BOOLEAN, fallback_mode, fallback_value: INT, op, a: INT, b: INT | INT |

RandomInt uses signed 64-bit integer fields. The constraint dropdown limits generated or stepped values to Full range, 1 to max Int, 0 to max Int, Min int to -1, Min int to 0, or Custom min/max. The min and max fields default to -1 and 1; they are always visible and are only used when Custom min/max is selected. The control_after_generation dropdown can keep the value Fixed, Increment it, Decrement it, or Randomize a new value when the workflow triggers the node. Generated, incremented, and decremented values are written back to the visible value widget after execution.

Integer Operators

| Operator | Applicable for | Description | Exmaple | | --- | --- | --- | --- | | Abs | IntUnaryOperation, IntUnaryOperationConditional | Returns the absolute value. | Abs -12 → 12 | | Neg | IntUnaryOperation, IntUnaryOperationConditional | Negates the input. | Neg 1 → -1 | | Inc | IntUnaryOperation, IntUnaryOperationConditional | Adds one. | Inc 10 → 11 | | Dec | IntUnaryOperation, IntUnaryOperationConditional | Subtracts one. | Dec 2 → 1 | | Sqr | IntUnaryOperation, IntUnaryOperationConditional | Squares the input. | Sqr -3 → 9 | | Cube | IntUnaryOperation, IntUnaryOperationConditional | Cubes the input. | Cube -3 → -27 | | Not | IntUnaryOperation, IntUnaryOperationConditional | Applies bitwise NOT. | Not 4 → -5 | | Factorial | IntUnaryOperation, IntUnaryOperationConditional | Returns the factorial. | Factorial 5 → 120 | | IsZero | IntUnaryCondition | Tests whether the input is zero. | IsZero 0 → True | | IsNonZero | IntUnaryCondition | Tests whether the input is not zero. | IsNonZero 4 → True | | IsPositive | IntUnaryCondition | Tests whether the input is positive. | IsPositive 4 → True | | IsNegative | IntUnaryCondition | Tests whether the input is negative. | IsNegative -4 → True | | IsEven | IntUnaryCondition | Tests whether the input is even. | IsEven 2 → True | | IsOdd | IntUnaryCondition | Tests whether the input is odd. | IsOdd 1 → True | | Add | IntBinaryOperation, IntBinaryOperationConditional | Adds both inputs. | 20 Add 80 → 100 | | Sub | IntBinaryOperation, IntBinaryOperationConditional | Subtracts the second input. | 20 Sub 80 → -60 | | Mul | IntBinaryOperation, IntBinaryOperationConditional | Multiplies both inputs. | 20 Mul 80 → 1600 | | Div | IntBinaryOperation, IntBinaryOperationConditional | Performs floor division. | 80 Div 20 → 4 | | Mod | IntBinaryOperation, IntBinaryOperationConditional | Returns the division remainder. | 100 Mod 80 → 20 | | Pow | IntBinaryOperation, IntBinaryOperationConditional | Raises the first input to the second. | 2 Pow 2 → 4 | | And | IntBinaryOperation, IntBinaryOperationConditional | Applies bitwise AND. | 2 And 3 → 2 | | Nand | IntBinaryOperation, IntBinaryOperationConditional | Applies bitwise NAND. | 10 Nand 3 → -3 | | Or | IntBinaryOperation, IntBinaryOperationConditional | Applies bitwise OR. | 4 Or 6 → 6 | | Nor | IntBinaryOperation, IntBinaryOperationConditional | Applies bitwise NOR. | 4 Nor 6 → -7 | | Xor | IntBinaryOperation, IntBinaryOperationConditional | Applies bitwise XOR. | 4 Xor 6 → 2 | | Xnor | IntBinaryOperation, IntBinaryOperationConditional | Applies bitwise XNOR. | 4 Xnor 6 → -3 | | Shl | IntBinaryOperation, IntBinaryOperationConditional | Shifts bits left. | 4 Shl 4 → 64 | | Shr | IntBinaryOperation, IntBinaryOperationConditional | Shifts bits right. | -1 Shr 2 → -1 | | Max | IntBinaryOperation, IntBinaryOperationConditional | Returns the larger input. | 20 Max 80 → 80 | | Min | IntBinaryOperation, IntBinaryOperationConditional | Returns the smaller input. | 20 Min 80 → 20 | | Eq | IntBinaryCondition | Tests whether the inputs are equal. | 4 Eq 4 → True | | Neq | IntBinaryCondition | Tests whether the inputs differ. | 4 Neq 5 → True | | Gt | IntBinaryCondition | Tests whether the first input is greater. | 9 Gt 4 → True | | Lt | IntBinaryCondition | Tests whether the first input is smaller. | 4 Lt 9 → True | | Geq | IntBinaryCondition | Tests whether the first input is greater or equal. | 4 Geq 4 → True | | Leq | IntBinaryCondition | Tests whether the first input is smaller or equal. | 4 Leq 9 → True |

Float Nodes

| Node | Purpose | Inputs | Outputs | | --- | --- | --- | --- | | FloatUnaryOperation | Applies a unary float operation. Operations include arithmetic helpers, roots/logs, trig/hyperbolic functions, rounding, error/gamma functions, and radians/degrees conversion. | op, a: FLOAT | FLOAT | | FloatUnaryCondition | Tests one float value. Conditions include zero/non-zero, sign, finite/infinite, NaN, even, and odd. | op, a: FLOAT | BOOLEAN | | FloatBinaryOperation | Applies a binary float operation. Operations: Add, Sub, Mul, Div, Mod, Pow, FloorDiv, Max, Min, Log, Atan2. | op, a: FLOAT, b: FLOAT | FLOAT | | FloatBinaryCondition | Compares two float values. Conditions: Eq, Neq, Gt, Gte, Lt, Lte. | op, a: FLOAT, b: FLOAT | BOOLEAN | | FloatUnaryOperationConditional | Applies a unary float operation only when condition is true; otherwise returns a or fallback_value. | condition: BOOLEAN, fallback_mode, fallback_value: FLOAT, op, a: FLOAT | FLOAT | | FloatBinaryOperationConditional | Applies a binary float operation only when condition is true; otherwise returns a, b, or fallback_value. | condition: BOOLEAN, fallback_mode, fallback_value: FLOAT, op, a: FLOAT, b: FLOAT | FLOAT |

Float Operators

| Operator | Applicable for | Description | Exmaple | | --- | --- | --- | --- | | Neg | FloatUnaryOperation, FloatUnaryOperationConditional | Negates the input. | Neg 2.5 → -2.5 | | Inc | FloatUnaryOperation, FloatUnaryOperationConditional | Adds one. | Inc 10.12 → 11.12 | | Dec | FloatUnaryOperation, FloatUnaryOperationConditional | Subtracts one. | Dec 2.0 → 1.0 | | Abs | FloatUnaryOperation, FloatUnaryOperationConditional | Returns the absolute value. | Abs -12.0 → 12.0 | | Sqr | FloatUnaryOperation, FloatUnaryOperationConditional | Squares the input. | Sqr -3.0 → 9.0 | | Cube | FloatUnaryOperation, FloatUnaryOperationConditional | Cubes the input. | Cube -3.0 → -27.0 | | Sqrt | FloatUnaryOperation, FloatUnaryOperationConditional | Returns the square root. | Sqrt 9.0 → 3.0 | | Exp | FloatUnaryOperation, FloatUnaryOperationConditional | Raises e to the input. | Exp 1.0 → 2.718... | | Ln | FloatUnaryOperation, FloatUnaryOperationConditional | Returns the natural logarithm. | Ln e → 1.0 | | Log10 | FloatUnaryOperation, FloatUnaryOperationConditional | Returns the base-10 logarithm. | Log10 100.0 → 2.0 | | Log2 | FloatUnaryOperation, FloatUnaryOperationConditional | Returns the base-2 logarithm. | Log2 8.0 → 3.0 | | Sin | FloatUnaryOperation, FloatUnaryOperationConditional | Returns the sine in radians. | Sin (π / 2) → 1.0 | | Cos | FloatUnaryOperation, FloatUnaryOperationConditional | Returns the cosine in radians. | Cos π → -1.0 | | Tan | FloatUnaryOperation, FloatUnaryOperationConditional | Returns the tangent in radians. | Tan (π / 4) → 1.0 | | Asin | FloatUnaryOperation, FloatUnaryOperationConditional | Returns the inverse sine. | Asin 1.0 → π / 2 | | Acos | FloatUnaryOperation, FloatUnaryOperationConditional | Returns the inverse cosine. | Acos 0.0 → π / 2 | | Atan | FloatUnaryOperation, FloatUnaryOperationConditional | Returns the inverse tangent. | Atan 1.0 → π / 4 | | Sinh | FloatUnaryOperation, FloatUnaryOperationConditional | Returns the hyperbolic sine. | Sinh 1.0 → 1.1752... | | Cosh | FloatUnaryOperation, FloatUnaryOperationConditional | Returns the hyperbolic cosine. | Cosh 0.0 → 1.0 | | Tanh | FloatUnaryOperation, FloatUnaryOperationConditional | Returns the hyperbolic tangent. | Tanh 1.0 → 0.7615... | | Asinh | FloatUnaryOperation, FloatUnaryOperationConditional | Returns the inverse hyperbolic sine. | Asinh 1.0 → 0.8813... | | Acosh | FloatUnaryOperation, FloatUnaryOperationConditional | Returns the inverse hyperbolic cosine. | Acosh 1.0 → 0.0 | | Atanh | FloatUnaryOperation, FloatUnaryOperationConditional | Returns the inverse hyperbolic tangent. | Atanh 0.99 → 2.6466... | | Round | FloatUnaryOperation, FloatUnaryOperationConditional | Rounds to the nearest integer. | Round 1.6 → 2.0 | | Floor | FloatUnaryOperation, FloatUnaryOperationConditional | Rounds down. | Floor 1.6 → 1.0 | | Ceil | FloatUnaryOperation, FloatUnaryOperationConditional | Rounds up. | Ceil 1.1 → 2.0 | | Trunc | FloatUnaryOperation, FloatUnaryOperationConditional | Removes the fractional part. | Trunc -3.5 → -3.0 | | Erf | FloatUnaryOperation, FloatUnaryOperationConditional | Returns the error function. | Erf 0.0 → 0.0 | | Erfc | FloatUnaryOperation, FloatUnaryOperationConditional | Returns the complementary error function. | Erfc 0.0 → 1.0 | | Gamma | FloatUnaryOperation, FloatUnaryOperationConditional | Returns the gamma function. | Gamma 8.0 → 5040.0 | | Radians | FloatUnaryOperation, FloatUnaryOperationConditional | Converts degrees to radians. | Radians 180.0 → π | | Degrees | FloatUnaryOperation, FloatUnaryOperationConditional | Converts radians to degrees. | Degrees π → 180.0 | | IsZero | FloatUnaryCondition | Tests whether the input is zero. | IsZero 0.0 → True | | IsPositive | FloatUnaryCondition | Tests whether the input is positive. | IsPositive 4.5 → True | | IsNegative | FloatUnaryCondition | Tests whether the input is negative. | IsNegative -4.5 → True | | IsNonZero | FloatUnaryCondition | Tests whether the input is not zero. | IsNonZero 4.5 → True | | IsPositiveInfinity | FloatUnaryCondition | Tests for positive infinity. | IsPositiveInfinity inf → True | | IsNegativeInfinity | FloatUnaryCondition | Tests for negative infinity. | IsNegativeInfinity -inf → True | | IsNaN | FloatUnaryCondition | Tests for a NaN value. | IsNaN nan → True | | IsFinite | FloatUnaryCondition | Tests for a finite value. | IsFinite 4.5 → True | | IsInfinite | FloatUnaryCondition | Tests for either infinity. | IsInfinite inf → True | | IsEven | FloatUnaryCondition | Tests for an even whole value. | IsEven 2.0 → True | | IsOdd | FloatUnaryCondition | Tests for a non-even value. | IsOdd 2.1 → True | | Add | FloatBinaryOperation, FloatBinaryOperationConditional | Adds both inputs. | 20.0 Add 80.0 → 100.0 | | Sub | FloatBinaryOperation, FloatBinaryOperationConditional | Subtracts the second input. | 20.0 Sub 80.0 → -60.0 | | Mul | FloatBinaryOperation, FloatBinaryOperationConditional | Multiplies both inputs. | 2.5 Mul 4.0 → 10.0 | | Div | FloatBinaryOperation, FloatBinaryOperationConditional | Divides the first input by the second. | 20.0 Div 80.0 → 0.25 | | Mod | FloatBinaryOperation, FloatBinaryOperationConditional | Returns the division remainder. | 100.0 Mod 80.0 → 20.0 | | Pow | FloatBinaryOperation, FloatBinaryOperationConditional | Raises the first input to the second. | 2.0 Pow 2.0 → 4.0 | | FloorDiv | FloatBinaryOperation, FloatBinaryOperationConditional | Divides and rounds down. | 20.0 FloorDiv 80.0 → 0.0 | | Max | FloatBinaryOperation, FloatBinaryOperationConditional | Returns the larger input. | 20.0 Max 80.0 → 80.0 | | Min | FloatBinaryOperation, FloatBinaryOperationConditional | Returns the smaller input. | 20.0 Min 80.0 → 20.0 | | Log | FloatBinaryOperation, FloatBinaryOperationConditional | Returns a logarithm with the given base. | 8.0 Log 2.0 → 3.0 | | Atan2 | FloatBinaryOperation, FloatBinaryOperationConditional | Returns the angle from two coordinates. | 1.0 Atan2 1.0 → π / 4 | | Eq | FloatBinaryCondition | Tests whether the inputs are equal. | 4.0 Eq 4.0 → True | | Neq | FloatBinaryCondition | Tests whether the inputs differ. | 4.0 Neq 5.0 → True | | Gt | FloatBinaryCondition | Tests whether the first input is greater. | 9.0 Gt 4.0 → True | | Gte | FloatBinaryCondition | Tests whether the first input is greater or equal. | 4.0 Gte 4.0 → True | | Lt | FloatBinaryCondition | Tests whether the first input is smaller. | 4.0 Lt 9.0 → True | | Lte | FloatBinaryCondition | Tests whether the first input is smaller or equal. | 4.0 Lte 9.0 → True |

Number Nodes

NUMBER accepts integer or float-like values and runs the same operation sets as the float nodes after converting inputs to float.

| Node | Purpose | Inputs | Outputs | | --- | --- | --- | --- | | NumberUnaryOperation | Applies a float-style unary operation to a generic number. | op, a: NUMBER | NUMBER | | NumberUnaryCondition | Tests a generic number with the float-style unary conditions. | op, a: NUMBER | BOOLEAN | | NumberBinaryOperation | Applies a float-style binary operation to two generic numbers. | op, a: NUMBER, b: NUMBER | NUMBER | | NumberBinaryCondition | Compares two generic numbers with the float-style binary conditions. | op, a: NUMBER, b: NUMBER | BOOLEAN | | NumberUnaryOperationConditional | Applies a unary number operation only when condition is true; otherwise returns a or fallback_value. | condition: BOOLEAN, fallback_mode, fallback_value: NUMBER, op, a: NUMBER | NUMBER | | NumberBinaryOperationConditional | Applies a binary number operation only when condition is true; otherwise returns a, b, or fallback_value. | condition: BOOLEAN, fallback_mode, fallback_value: NUMBER, op, a: NUMBER, b: NUMBER | NUMBER |

Vector Nodes

The same node families are provided for VEC2, VEC3, and VEC4.

| Node Pattern | Purpose | Inputs | Outputs | | --- | --- | --- | --- | | VecNUnaryOperation | Applies vector unary operations. Operations: Neg, Normalize. | op, a: VECN | VECN | | VecNToScalarUnaryOperation | Converts one vector to a scalar. Operations: Norm. | op, a: VECN | FLOAT | | VecNUnaryCondition | Tests one vector. Conditions: zero/non-zero and normalized/not normalized. | op, a: VECN | BOOLEAN | | VecNBinaryOperation | Applies vector binary operations. Operations: Add, Sub, Cross. Note: Cross is currently only usable as a Vec3 operation; NumPy returns a scalar for Vec2, which does not match this node output conversion, and Vec4 is invalid. | op, a: VECN, b: VECN | VECN | | VecNToScalarBinaryOperation | Converts two vectors to a scalar. Operations: Dot, Distance. | op, a: VECN, b: VECN | FLOAT | | VecNBinaryCondition | Compares two vectors. Conditions: Eq, Neq. | op, a: VECN, b: VECN | BOOLEAN | | VecNScalarOperation | Applies scalar multiplication or division to a vector. Operations: Mul, Div. | op, a: VECN, b: FLOAT | VECN |

Registered vector node names replace N with 2, 3, or 4, for example Vec2UnaryOperation, Vec3ScalarOperation, and Vec4ToScalarBinaryOperation.

Vector Operators

| Operator | Applicable for | Description | Example | | --- | --- | --- | --- | | Neg | VecNUnaryOperation | Negates every vector component. | Neg (1, -2) → (-1, 2) | | Normalize | VecNUnaryOperation | Divides the vector by its Euclidean norm to produce a unit vector. | Normalize (3, 4) → (0.6, 0.8) | | Norm | VecNToScalarUnaryOperation | Returns the Euclidean length of the vector. | Norm (3, 4) → 5 | | IsZero | VecNUnaryCondition | Tests whether every component is zero. | IsZero (0, 0) → True | | IsNotZero | VecNUnaryCondition | Tests whether at least one component is non-zero. | IsNotZero (0, 1) → True | | IsNormalized | VecNUnaryCondition | Tests whether the vector has unit length. | IsNormalized (1, 0) → True | | IsNotNormalized | VecNUnaryCondition | Tests whether the vector does not have unit length. | IsNotNormalized (3, 4) → True | | Add | VecNBinaryOperation | Adds corresponding components. | (1, 2) Add (3, 4) → (4, 6) | | Sub | VecNBinaryOperation | Subtracts corresponding components of the second vector from the first. | (3, 4) Sub (1, 2) → (2, 2) | | Cross | Vec3BinaryOperation | Returns the three-dimensional cross product. | (1, 0, 0) Cross (0, 1, 0) → (0, 0, 1) | | Dot | VecNToScalarBinaryOperation | Returns the sum of the products of corresponding components. | (1, 2) Dot (3, 4) → 11 | | Distance | VecNToScalarBinaryOperation | Returns the Euclidean distance between both vectors. | (0, 0) Distance (3, 4) → 5 | | Eq | VecNBinaryCondition | Tests whether corresponding components are approximately equal. | (1, 2) Eq (1, 2) → True | | Neq | VecNBinaryCondition | Tests whether the vectors are not approximately equal. | (1, 2) Neq (1, 3) → True | | Mul | VecNScalarOperation | Multiplies every vector component by a scalar. | (1, -2) Mul 3 → (3, -6) | | Div | VecNScalarOperation | Divides every vector component by a scalar. | (4, -2) Div 2 → (2, -1) |

Conversion Nodes

| Node | Purpose | Inputs | Outputs | | --- | --- | --- | --- | | BoolToInt | Converts False/True to 0/1. | a: BOOLEAN | INT | | IntToBool | Converts 0 to False and any other integer to True, also negative numbers. | a: INT | BOOLEAN | | FloatToInt | Converts a float to an integer using Python int() truncation. | a: FLOAT | INT | | IntToFloat | Converts an integer to a float. | a: INT | FLOAT | | IntToNumber | Passes an integer as a generic number. | a: INT | NUMBER | | NumberToInt | Converts a generic number to an integer using Python int() truncation. | a: NUMBER | INT | | FloatToNumber | Passes a float as a generic number. | a: FLOAT | NUMBER | | NumberToFloat | Converts a generic number to a float. | a: NUMBER | FLOAT | | ComposeVec2 | Builds a Vec2 from component floats. | x: FLOAT, y: FLOAT | VEC2 | | ComposeVec3 | Builds a Vec3 from component floats. | x: FLOAT, y: FLOAT, z: FLOAT | VEC3 | | ComposeVec4 | Builds a Vec4 from component floats. | x: FLOAT, y: FLOAT, z: FLOAT, w: FLOAT | VEC4 | | BreakoutVec2 | Splits a Vec2 into component floats. | a: VEC2 | FLOAT, FLOAT | | BreakoutVec3 | Splits a Vec3 into component floats. | a: VEC3 | FLOAT, FLOAT, FLOAT | | BreakoutVec4 | Splits a Vec4 into component floats. | a: VEC4 | FLOAT, FLOAT, FLOAT, FLOAT |

Control Nodes

| Node | Purpose | Inputs | Outputs | | --- | --- | --- | --- | | ChooseInt | Returns a when condition is true, otherwise returns b. | condition: BOOLEAN, a: INT, b: INT | INT | | ChooseFloat | Returns a when condition is true, otherwise returns b. | condition: BOOLEAN, a: FLOAT, b: FLOAT | FLOAT |

Graphics Nodes

| Node | Purpose | Inputs | Outputs | | --- | --- | --- | --- | | SDXLResolution | Selects one of the standard SDXL width/height presets. | resolution | width: INT, height: INT | | NearestSDXLResolution | Chooses the standard SDXL preset whose aspect ratio is nearest to the input image. | image: IMAGE | width: INT, height: INT | | SDXLExtendedResolution | Selects one of the extended SDXL width/height presets. | resolution | width: INT, height: INT | | NearestSDXLExtendedResolution | Chooses the extended SDXL preset whose aspect ratio is nearest to the input image. | image: IMAGE | width: INT, height: INT | | AspectRatioResolution | Calculates dimensions near a target megapixel count for a selected aspect ratio and pixel multiple. | aspect_ratio, megapixels: FLOAT, multiple: INT | width: INT, height: INT | | ImageAspectResolution | Calculates dimensions near a target megapixel count using an input image's aspect ratio and a pixel multiple. | image: IMAGE, megapixels: FLOAT, multiple: INT | width: INT, height: INT |

Resolution Guidance

The generic resolution nodes are preferable to separate preset nodes for modern model families because those models support flexible dimensions rather than one authoritative finite preset list. A megapixel value is an approximate target; rounding to the requested pixel multiple can produce a slightly larger or smaller image.

| Model family | Resolution guidance | Suggested generic-node settings | | --- | --- | --- | | Stable Diffusion 1.5 | The base model was fine-tuned at 512×512. | 1:1, 0.25 MP, multiple 64 | | Stable Diffusion 2 | Use 512×512 for base checkpoints and 768×768 for the 768-series checkpoints. | 1:1, 0.25 or 0.5625 MP, multiple 64 | | Stable Diffusion 3.5 | Approximately 1 MP is the standard target, with several supported aspect ratios. Local runtimes can support additional dimensions. | 1.0 MP; use the pixel multiple required by the local workflow | | FLUX.1 | Model variants and runtimes differ; 1 MP is a practical starting point rather than a fixed preset requirement. | 1.0 MP; use the pixel multiple required by the selected variant | | FLUX.2 | Supports any aspect ratio from 64×64 up to 4 MP in multiples of 16; up to 2 MP is recommended for quality and speed. | 1.0–2.0 MP, multiple 16 |

Limitations

• Math errors are not caught. Examples: division by zero, invalid logarithm/square-root domains, invalid factorial input, and normalizing a zero vector may raise errors or produce non-finite values.
• Float equality uses exact Python comparison; vector equality uses NumPy allclose.
• Floating-point operations can produce small rounding errors. For example, in a float node, 1.1 + 0.1 may result in 1.2000000000000002 instead of the expected 1.2
• Integer Div uses floor division (//), not true division. Use IntToFloat first, then a float or number division node when a fractional result is needed.
• FloatToInt and NumberToInt truncate toward zero.
• FillVec2, FillVec3, and FillVec4 classes exist in convert.py, but are not referenced elsewhere or registered in NODE_CLASS_MAPPINGS. They are currently orphaned/unexposed convenience helpers for creating vectors with all components set to the same value.

Further References

• ComfyUI custom nodes: https://github.com/comfyanonymous/ComfyUI
• Python math module behavior: https://docs.python.org/3/library/math.html
• NumPy vector operations used by vector nodes: https://numpy.org/doc/stable/reference/routines.linalg.html

Credits

This repo was originally cloned from https://github.com/evanspearman/ComfyMath.

Additional features were added, according to a PR proposal of dnnagy.