Crate zalgo_codec

This is a crate implementing the zalgo encoding and decoding functions originally written in Python by Scott Conner and extends them for Rust by providing a procedural macro that can run encoded source code.

With the functions defined in this crate you can transform an ASCII string into a unicode string that is a single “character” wide in a reversible way. The encoded string will be ~2 times larger than the original in terms of bytes.

The crate also provides the zalgo_embed! macro that can be used to execute encoded source code. Imagine the code clarity!

Additionally the crate provides a function to encode Python code and wrap the result in a decoder that decodes and executes the encoded string, retaining the functionality of the original code.

Example

The cursed character is the result of using zalgo_encode on the text fn add(x: i32, y: i32) -> i32 {x + y}.

// We can add that text to our code with the macro
zalgo_embed!("E͎͉͙͉̞͉͙͆̀́̈́̈́̈̀̓̒̌̀̀̓̒̉̀̍̀̓̒̀͛̀̋̀͘̚̚͘͝");

// The `add` function is now available
assert_eq!(add(10, 20), 30);

Explanation

Characters U+0300–U+036F are the combining characters for unicode Latin. The fun thing about combining characters is that you can add as many of these characters as you like to the original character and it does not create any new symbols, it only adds symbols on top of the character. It’s supposed to be used in order to create characters such as á by taking a normal a and adding another character to give it the mark (U+301, in this case). Fun fact, Unicode doesn’t specify any limit on the number of these characters. Conveniently, this gives us 112 different characters we can map to, which nicely maps to the ASCII character range 0x20 -> 0x7F, aka all the non-control characters. The only issue is that we can’t have new lines in this system, so to fix that, we can simply map 0x7F (DEL) to 0x0A (LF). This can be represented as (CHARACTER - 11) % 133 - 21, and decoded with (CHARACTER + 22) % 133 + 10.

Features

files: enabled by default, provides the functions encode_file, decode_file and wrap_python_file.

Links

The original post where the Python code was first presented together with the above explanation.

Macros

zalgo_embed

This macro decodes a Unicode string that has been encoded with zalgo_encode and passes the results on to the compiler.

Structs

UnencodableByteError

The error returned by the encoding functions if they encounter a byte they can not encode.

Enums

UndecodableFileError

The error returned by the decoding functions that interact with the file system.

UnencodableFileError

The error returned by the encoding functions that interact with the file system.

Functions

decode_file

Decodes the contents of a file that has been encoded with encode_file and stores the result in another file.

encode_file

Encodes the contents of the file and stores the result in another file. If carriage return characters are found it will print a message and attempt to encode the file anyway by ignoring them.

wrap_python_file

Encodes the contents of the given Python source file and stores the result wrapped in a decoder in another file. This new file retains the functionality of the original. If the source file contains carriage return characters this function will print a message and then attempt to encode it anyway by ignoring them.

zalgo_decode

Takes in a string that was encoded by zalgo_encode and decodes it back into an ASCII string.

zalgo_encode

Takes in an ASCII string without control characters (except newlines) and “compresses” it to zalgo text using a reversible encoding scheme. The resulting string is a single unicode grapheme cluster and should only take up a single character space horizontally when displayed (though this can vary between platforms depending on how they deal with unicode). The resulting string will be ~2 times larger than the original in terms of bytes, and it can be decoded to recover the original string using zalgo_decode.

zalgo_wrap_python

zalgo-encodes an ASCII string containing Python code and wraps it in a decoder that decodes and executes it. The resulting Python code should retain the functionality of the original.