Does every character get a different random permutation?

No, and that's deliberate. One permutation of the 7 bit positions is generated from your seed, and that exact same permutation is applied to every character in the input. If each character got its own random permutation, the transform wouldn't be a well-defined, reversible cipher, you'd need to store a separate permutation per character just to undo it.

Is this reproducible? Will I get the same output every time?

Yes, for the same input text and the same seed, always. The permutation is derived from the seed using a seeded pseudorandom generator (mulberry32), not JavaScript's Math.random(), so there's no hidden randomness involved. Change the seed and you get a different permutation and different output; keep it the same and results are exactly reproducible.

How is this different from the ASCII Bit Flipper?

The ASCII Bit Flipper toggles a single bit position (via XOR) and leaves the other six untouched. This tool instead reorders all 7 bit positions using a permutation, every bit stays a 0 or 1, but which position it ends up in changes. Neither tool changes how many 0s or 1s are in a character's code, a bit flip changes the count by exactly one, while a permutation preserves it exactly.

How is this different from the Hex Nibble Shuffler?

The Hex Nibble Shuffler reorders whole 4-bit nibbles within a hex-digit string. This tool reorders individual bits, at a finer 1-bit granularity, within each 7-bit ASCII character code. They operate on different underlying representations (hex digit strings vs. ASCII character codes) and at different granularities (nibbles vs. bits).

ASCII Bit Shuffler - Seeded 7-Bit Permutation Cipher

Overview

Introduction

Beyond flipping bits, you can also just move them around: take the same 7 bits that make up a character's ASCII code and rearrange which position each one lives in.

This tool does that rearrangement with a seeded, reproducible permutation, applied identically to every character, so the same input and seed always produce the exact same scrambled text.

What Is ASCII Bit Shuffler?

A seeded bit-transposition tool: it picks one random ordering of the 7 ASCII bit positions from your numeric seed, then reuses that single ordering for every character in your input.

Unlike substitution ciphers that change bit values, this only ever changes bit positions, so the number of 1-bits in each character's code is preserved exactly, only their arrangement changes.

How ASCII Bit Shuffler Works

A Fisher-Yates shuffle of the array [0,1,2,3,4,5,6], driven by a mulberry32 pseudorandom generator seeded from your numeric seed, produces one permutation of the 7 bit positions.

For every character, each of its 7 bits is moved from its original position to the position the permutation assigns it, then the bits are reassembled into a new ASCII code.

When To Use ASCII Bit Shuffler

Use it to build a simple, reproducible bit-transposition example for teaching classical vs. modern cipher design (substitution vs. transposition).

It's also useful for generating scrambled-but-reversible test fixtures where you need the exact same scramble every time you use a given seed.

Often used alongside ASCII Bit Flipper, ASCII Character Shuffler and Hex Nibble Shuffler.

Features

Advantages

Fully reproducible: the same input and seed always produce identical output, useful for tests and demos.
Preserves each character's bit count (number of 1s), unlike a bit flip or substitution.
Reversible by computing and applying the inverse permutation (or by re-running the underlying logic with the permutation inverted).

Limitations

This tool's UI applies the permutation forward only; decoding requires knowing the seed and applying the inverse permutation, which isn't exposed as a separate 'decode' button here.
As a bit-transposition scheme, it offers no real cryptographic security, it's for demonstration and reproducible scrambling, not confidentiality.

Examples

Shuffling with seed 4

Input

Output

Seed 4 generates the bit permutation [2,4,3,0,5,1,6]; applying it to 'A' (65, binary 1000001) rearranges the bits to produce code 68, which is 'D'.

The same permutation applies to every character

Input

AB

Output

DP

Seed 4's permutation is reused for both characters: 'A' (65) becomes 'D' (68) and 'B' (66) becomes 'P' (80), the same bit rearrangement rule applied twice.

Best Practices & Notes

Best Practices

Record the seed alongside any output you need to reference again later, without it you can't reproduce or reverse the exact scramble.
Use small, memorable seeds (like 1, 42, or a project-specific number) so your test fixtures stay easy to regenerate.

Developer Notes

Generates the permutation with a standard Fisher-Yates shuffle over `[0,1,2,3,4,5,6]`, using `mulberry32(seed)` from the shared `seeded-random.ts` helper (also used by the string category's seeded text tools) rather than `Math.random()`, so results are stable across server and client renders. Each character's bits are extracted with `(code >> i) & 1` and reassembled with `result |= bit << permutation[i]`.

ASCII Bit Shuffler Use Cases

Demonstrating bit-level transposition as distinct from substitution in a cryptography or CS fundamentals lesson
Generating reproducible scrambled test fixtures keyed by a simple numeric seed
Exploring how rearranging bits (vs. flipping them) changes ASCII text differently

Common Mistakes

Assuming a different seed produces a proportionally 'more scrambled' result, permutations aren't ordered by scrambling strength, they're just different arrangements.
Forgetting the seed used to produce a given output, which makes it hard to reproduce or reason about later.

Tips

Try the same input with several different seeds side by side to get a feel for how much a single permutation choice changes the output.
Pair with the ASCII Bit Flipper to compare position-based scrambling against value-based single-bit corruption.

ASCII Bit Shuffler