Progressive Caesar Cipher

The Progressive Caesar (sometimes called a "progressive shift" or "advancing" Caesar) is what happens when a plain Caesar stops being enough of a puzzle. Instead of every letter shifting by the same fixed amount, the shift increases by one for each letter you move through the message: the first letter shifts by key, the second by key + 1, the third by key + 2, and so on, wrapping around your alphabet when it runs off the end. It's a genuinely historical idea - variant ciphers like this were a real step up from ROT because a naive "try all 26 shifts" brute force stops working; the repeating-but-growing pattern resists the obvious attacks that break plain Caesar.

In an ARG that's exactly why it shows up: it's a classic cipher that still feels like a "real" puzzle to solvers, and it's the natural middle ground between the trivially-breakable Caesar node and the keyed ciphers like Vigenère. Reach for it when a puzzle hands you a string that clearly isn't a plain shift but is too regular to be a keyword cipher.

How it works

Under the hood it's the same machinery as every other classical cipher in this pack - a thin wrapper around secretpy.CaesarProgressive, sharing the BaseCipherNode input layout. The one meaningful difference is what happens to the key you provide: it's the starting shift, and it climbs by one per character as the cipher walks through the text. Decryption is the exact inverse - the same progressive drift, applied in reverse - so mode (labeled encrypt/decrypt) and the same key on both sides will always round-trip.

Because it rides on the shared base, you get the same supporting cast: alphabet accepts a named secretpy alphabet like ENGLISH or a custom alphabet string, keep_formatting preserves spaces/punctuation/case when on (or strips everything to lowercase when off), and the output is a single encrypted_txt string.

The inputs that matter

• text - the message, matching the alphabet's language.
• key - an integer starting shift. Default 13, any non-negative value. Changing the starting offset changes the whole ciphertext, so both sides need the same value.
• alphabet - ENGLISH by default; type a custom connected alphabet to encrypt in another character set.
• mode - encrypt/decrypt toggle.
• keep_formatting - preserve original spacing/case, or strip to lowercase letters.

Output: encrypted_txt.

Installing it

Part of the ComfyUI ARG Toolkit pack. Install via ComfyUI Manager (search "ComfyUI ARG Toolkit") or:

cd ComfyUI/custom_nodes
git clone https://github.com/AzelusLightvale/ComfyUI-ARG-Toolkit

Restart ComfyUI. Pack-wide install pulls secretpy for this category plus cryptography, stegano, invisible-watermark, reedsolo, and transitively torch and opencv-python. No models, no API keys.

Gotchas

The mental trap here is assuming the key is a constant shift - it isn't, and that's the whole trick, so don't be surprised when plaintext "aaaaaa" doesn't produce a nice straight run. Also note keep_formatting and the alphabet rules are shared with the base cipher node: if your output is all-lowercase with no spaces, you left keep_formatting off, and if letters come out garbled, your alphabet doesn't match the text. Since the author is upfront that this is a hobbyist project with tests covering only common cases, treat weird alphabets as "test it before you trust it."