` with an `onclick`.
- Stops inside `aria-hidden="true"`, which screen readers skip.
Click in the page and press Tab to follow the order yourself; the line above the page says which stop has focus.
#### Example
Press **Try an example**. The HTML has two links, a search field with `tabindex="1"`, a "Buy now" `
` with an
`onclick`, a button holding only an image with no `alt`, and a Help link.
The message says `5 stops in the tab order. 3 things to look at.` The search field is first, the button is #4 with
no name, and "Buy now" can't be reached with the keyboard.
#### Good to know
The page's scripts don't run here, so content a script adds or a menu that opens on click isn't seen, and focus
that a script moves isn't followed. Elements hidden by styles are left out. The names are worked out simply from
labels, `aria-label`, `aria-labelledby`, text and `alt`; a screen reader may word them differently.
### Colour Blindness Simulator
https://toolbox.thoughtasylum.com/colour-blind/
Simulate protanopia, deuteranopia, tritanopia and achromatopsia on an image or screenshot, with a severity slider, and save each view. Nothing is uploaded.
#### What it's for
See a picture as people with colour blindness see it. Around 1 in 12 men and 1 in 200 women have some colour
blindness, most often telling red from green. Charts, maps, status lights and "red means error" designs that rely on
colour alone can lose their meaning.
For example, before publishing a dashboard whose lines are red and green, take a screenshot and check here that the
lines can still be told apart.
#### How to use it
Choose a picture or screenshot, or drop or paste it on the page. **Show** picks every kind side by side, or one
kind with the original:
- **Protanopia** and **deuteranopia**: no red or no green cones, the common red–green colour blindness.
- **Tritanopia**: no blue cones, which confuses blue with green and yellow with pink.
- **Achromatopsia**: no colour at all.
**Severity** blends towards normal vision for the milder forms most people have (protanomaly, deuteranomaly and
tritanomaly). Each view has a **Save** button for a PNG. The choice of view is remembered in this browser.
#### Example
Take a screenshot of four blocks coloured red, green, blue and yellow, and choose it here with **Every kind**.
In the protanopia and deuteranopia views, the red and green blocks become similar olive browns and the yellow stays
yellow; in achromatopsia all four are greys.
#### Good to know
It uses the Machado, Oliveira and Fernandes (2009) model, a good approximation; no simulation shows exactly what a
given person sees. Severities below 100% blend the full simulation with the original, which is close to but not the
same as the model's own tables. Large pictures are scaled to 1,200 pixels across.
### Contrast Checker
https://toolbox.thoughtasylum.com/contrast/
Check colour contrast by WCAG 2 (AA, AAA) and APCA (Lc), see a preview, and get the nearest passing text colour. Any CSS colour. Free, in your browser.
#### What it's for
Text needs enough contrast with its background to be read, especially by people with low vision or on a screen in
sunlight. This checks a pair of colours by WCAG 2's contrast ratio, which accessibility laws and audits use, and by
APCA, the method drafted for WCAG 3, which matches how people actually see light and dark text better. When a pair
fails, it suggests the nearest text colour that passes.
For example, when a designer's grey `#8a8a8a` on white looks fine to you, check it here: it fails WCAG AA for
normal text at 3.45 : 1, and the nearest grey that passes is given, ready to copy.
#### How to use it
Type the **Text colour** and **Background** as any CSS colour (`#5b6178`, `rgb(0 0 0 / 60%)`, `oklch(…)`,
`rebeccapurple`), or pick them with the colour boxes. A see-through colour is blended over the one behind it
(the background over white). **Swap** exchanges them. As you type you see:
- A preview at three text sizes.
- **Nearest passing text colours**: the closest colour of the same hue that reaches AA, AAA and APCA's body
text level, each with a Copy button (shown only when the current one doesn't).
- **WCAG 2**: the ratio's pass or fail for normal and large text at AA and AAA, and for icons and borders.
- **APCA**: the Lc value against its simple guide, from body text (Lc 75 to 90) down to dividers (Lc 15).
Lc is positive for dark text on a light background and negative the other way round; the size counts, not the sign.
**Copy a link to this input** keeps both colours.
#### Example
Choose **Try an example**, which sets the text to `#8a8a8a` on `#ffffff`.
The message reads `WCAG 2: 3.45 : 1 (large text only). APCA: Lc 62.1.` It fails normal text at AA, and the
nearest passing colours are listed: a darker grey for AA, a darker one still for AAA.
#### Good to know
WCAG 2.x is still the standard that laws and audits use. APCA is a draft whose levels may change, so use it as a
second opinion. Neither takes font weight, size or anti-aliasing into account beyond the levels listed, and
colour blindness isn't covered (use the Colour Blindness Simulator). The suggestions keep the hue and change
only the lightness, so a very light or saturated colour may lose some of its character.
#### Link with input
`https://toolbox.thoughtasylum.com/contrast/#ct-fg=…&ct-bg=…` fills these fields in order (values URL-encoded; leave out any to keep its default) and runs the tool:
- `ct-fg` (Text colour): text
- `ct-bg` (Background): text
The result shows in these elements:
- `#ct-wcag` (WCAG 2): its text
- `#ct-apca` (APCA): its text
- `#ct-fix` (Nearest passing text colours): its text
- `#ct-msg`: the status line, with errors and summaries
## Audio
### Tone Generator
https://toolbox.thoughtasylum.com/tone-generator/
Play a sine, square, triangle or sawtooth tone at any frequency or note, sweep it, or make white, pink or brown noise, and save as WAV. Free.
#### What it's for
Make a test tone or noise. A steady tone at a known pitch is useful for checking speakers and headphones, tuning,
finding a rattle, or matching the pitch of tinnitus; a glide from low to high finds the frequencies a speaker or
room struggles with; and noise helps with masking sound or testing levels.
For example, when one side of your headphones sounds weaker, play a 1000 Hz sine wave and compare each side, then
try a glide from 20 to 20000 Hz to hear where each stops.
#### How to use it
Choose the **Sound**: a sine, square, triangle or sawtooth wave, or white, pink or brown noise. For a wave, give the
**Frequency** in hertz or as a note such as `A4`, `C#5` or `Eb3` (A4 is 440 Hz), and if you like a **Glide to**
frequency or note. **Glide** sets whether the pitch rises evenly as you'd hear it (each octave takes the same time)
or evenly in hertz. The message names the nearest note to each frequency.
Set the length in **Seconds** and the **Volume**, then **Play** (tick **Repeat until stopped** to loop it) or **Save
as WAV**. The sound, length and volume are remembered in this browser.
#### Example
Choose **Sine wave**, type `A4` in **Frequency** and `A5` in **Glide to**, and set **Seconds** to `3`.
The message says `440 Hz is A4, gliding to 880 Hz is A5.` **Play** sweeps up an octave over three seconds, and
**Save as WAV** saves `tone-440hz-880hz.wav`.
#### Good to know
Start with the volume low, especially with headphones: high and very low tones can be louder than they seem, and
some speakers can be damaged by long, loud tones. What you hear also depends on your speakers, which may not
reproduce very low or very high frequencies at all.
Tones are made at 48,000 samples a second, so frequencies up to 24,000 Hz are possible, beyond most people's
hearing. Square and sawtooth waves at high frequencies carry some distortion.
#### Link with input
`https://toolbox.thoughtasylum.com/tone-generator/#tg-wave=…&tg-freq=…&tg-to=…&tg-sweep=…&tg-secs=…&tg-vol=…` fills these fields in order (values URL-encoded; leave out any to keep its default) and runs the tool:
- `tg-wave` (Sound): one of `sine` (Sine wave), `square` (Square wave), `triangle` (Triangle wave), `sawtooth` (Sawtooth wave), `white` (White noise), `pink` (Pink noise), `brown` (Brown noise)
- `tg-freq` (Frequency: hertz or a note such as A4): text
- `tg-to` (Glide to (optional)): text
- `tg-sweep` (Glide): one of `log` (Evenly in pitch), `linear` (Evenly in hertz)
- `tg-secs` (Seconds): a number (min 0.1, max 600, step any)
- `tg-vol` (Volume (%)): a number (min 0, max 100)
It makes sound, so there's no text result to read.
- `#tg-msg`: the status line, with errors and summaries
### DTMF Tones
https://toolbox.thoughtasylum.com/dtmf/
Generate DTMF phone keypad tones for any number and save them as WAV, or decode the keys pressed in an audio recording. Free, in your browser.
#### What it's for
Make and recognise the tones a phone keypad plays. Each key sends a pair of tones (dual-tone multi-frequency, or
DTMF, also called touch tones), which phone systems use for dialling and menu choices. This plays them for any
number, and finds the keys pressed in a recording.
For example, when a puzzle or capture-the-flag challenge hides a phone number in an audio clip of beeps, open the
clip here to read the keys.
#### How to use it
**Make tones**: type the keys (`0` to `9`, `*`, `#` and `A` to `D`; a comma adds half a second's pause), set how
long each tone and the gap after it last (remembered in this browser), then **Play** or **Save as WAV**. Other
characters, such as spaces, are skipped.
**Find the keys in a recording**: choose a sound file, such as WAV, MP3 or M4A, or drop it on the box. You get the
keys heard, with a Copy button, and the time each one starts. A key held down counts once; pressing the same key
twice needs a gap between.
#### Example
In **Make tones**, type:
```
0123456789*#
```
**Save as WAV** saves `dtmf-0123456789sh.wav`. Open that file under **Find the keys in a recording**, and the keys
heard are `0123456789*#`, and the message says 12 keys heard in 0:02.40.
#### Good to know
Recognition works best on clear recordings. Speech, music or heavy compression can hide the tones or, rarely, be
taken for one. Tones shorter than about 40 milliseconds, or with gaps shorter than that, may be missed or joined.
Playing tones into a phone line can operate menus or dial numbers, so only play them into calls you mean to.
#### Link with input
`https://toolbox.thoughtasylum.com/dtmf/#dt-keys=…&dt-tone=…&dt-gap=…` fills these fields in order (values URL-encoded; leave out any to keep its default) and runs the tool:
- `dt-keys` (Keys: 0–9, *, #, A–D, and commas for pauses): text
- `dt-tone` (Each tone (milliseconds)): a number (min 40, max 1000)
- `dt-gap` (Gap (milliseconds)): a number (min 40, max 1000)
It makes sound, so there's no text result to read.
- `#dt-msg`: the status line, with errors and summaries
### Audio Trimmer
https://toolbox.thoughtasylum.com/audio-editor/
Audio converter and trimmer: open MP3, WAV, M4A or Ogg, cut, reverse or normalise it, and save as WAV, M4A or MP3. Nothing is uploaded.
#### What it's for
Make quick changes to a sound file without installing an editor: cut it down to the part you want, play it
backwards, change its speed, make it louder or quieter, fade it in and out, or turn stereo into mono, then save the
result.
For example, when you want a 20-second clip from a recording for a presentation, open it here, set the start and
end, add a short fade out, and save it.
#### How to use it
Choose a sound file (WAV, MP3, M4A, Ogg or FLAC, as far as this browser plays them), or drop it on the page. The
waveform shows the sound, with the part you're keeping in colour. Set **Start** and **End** in seconds, or click the
waveform to move whichever is nearer.
Then, if you like:
- **Play backwards** reverses it, and **Mono** mixes the channels into one.
- **Speed** from 0.25 (four times slower) to 4 (four times faster), like a tape: the pitch goes down or up too.
- **Volume change** in decibels (6 dB is about twice the level), or **Normalise**, which makes the loudest moment
−1 dB, just below the most a file can hold.
- **Fade in** and **Fade out**, in seconds.
**Play the result** plays it with the changes, **Stop** stops, and **Save** saves it, named like
`talk-edited.wav`. Choose **WAV** to keep every detail for more editing, or **AAC .m4a** or **MP3** for a small file
to share (about a tenth of the size, at 160 kbit/s); MP3 plays on anything, including old players and upload forms
that take nothing else. The choice is remembered. The original file isn't changed.
#### Example
In the Tone Generator, save a 2-second sine wave at `440` Hz, then open the file here.
The message says `0:02.00, mono, 48,000 Hz`. Set **Start** to `0.5` and **End** to `1.5`, tick **Normalise**, and
**Save** as **WAV**: the saved file is one second long, and its loudest point is −1 dB.
#### Good to know
AAC is made by the browser, which Chrome, Edge and Safari can do but Firefox can't; MP3 is made in every browser by
LAME, loaded the first time (150 KB). MP3 keeps at most two channels, and sound at a rate MP3 doesn't allow (such as
96 kHz) is converted to 48 kHz. Both lose a little detail each time they're made, so edit from the WAV or the
original, not from a saved .m4a or .mp3. Changing the speed
changes the pitch: there's no keeping the pitch while changing the tempo. Volume changes that push a sound past the
most a file can hold are clipped, which sounds harsh: use Normalise to avoid that.
The whole sound is held in memory, so very long recordings (an hour or more) may be slow or not open on some
devices.
### Tap Tempo & Metronome
https://toolbox.thoughtasylum.com/metronome/
Tap along to find a song's tempo in BPM, and play a steady online metronome with an accented first beat. Free, in your browser.
#### What it's for
Find the tempo of a piece of music, and keep time while you play. Tapping along gives the speed in beats per
minute (BPM); the metronome clicks steadily at any speed, with the first beat of each bar higher to mark it.
For example, when you're learning a song by ear, tap along to the recording to find its tempo, then practise with
the metronome at a slower speed and build up.
#### How to use it
**Tap tempo**: tap the button in time with the beat, with a mouse, finger or (once the button is selected) Space or
Enter. After two taps it shows the BPM, averaged over your last eight taps, and puts it in **Beats a minute**. Pause
for more than 2.5 seconds to start again.
**Metronome**: set **Beats a minute** (20 to 400) and **Beats to a bar**, and choose whether to **Accent the first
beat**, then **Start**. The dots show where you are in the bar. These settings are remembered in this browser.
#### Example
Tap the button steadily twice a second. After a few taps it shows about `120.0 BPM` and puts `120` in **Beats a
minute**. Set **Beats to a bar** to `3` and **Start**: you hear a high click and two lower ones, again and again,
at 120 beats a minute.
#### Good to know
Tapping is only as steady as your taps: tap for several bars for a reliable figure. The clicks are timed by the
device's sound system and stay steady while the page is busy, but some browsers slow or stop sound in a background
tab, so keep the page in front.
#### Link with input
`https://toolbox.thoughtasylum.com/metronome/#mn-bpm=…&mn-beats=…` fills these fields in order (values URL-encoded; leave out any to keep its default) and runs the tool:
- `mn-bpm` (Beats a minute): a number (min 20, max 400)
- `mn-beats` (Beats to a bar): a number (min 1, max 16)
It makes sound, so there's no text result to read.
- `#mn-msg`: the status line, with errors and summaries
### Audio Tags
https://toolbox.thoughtasylum.com/audio-tags/
Read the ID3, FLAC, M4A, Opus and WAV tags and M4B chapters in a sound file, save its cover art, and remove tags. Nothing is uploaded.
#### What it's for
See what a sound file says about itself, and remove it. Music and recordings carry tags: title, artist, album,
cover pictures, comments, the software and sometimes the person or company that made them. This shows the tags and
the file's format and length, saves the pictures, and saves a copy without the tags.
For example, before you share a recording made with a phone app, open it here to see what it records about you, and
save a copy without its tags.
#### How to use it
Choose a sound file, or drop it on the page. It reads:
- MP3, with ID3v2 (versions 2.2 to 2.4), ID3v1 and APE tags.
- FLAC and Ogg (Vorbis and Opus), with their comments and pictures.
- M4A, M4B, AAC and other MP4 audio, with iTunes-style tags and an audiobook's chapters.
- WAV, with its INFO list, ID3 chunk and broadcast (BWF) details.
The first table gives the format, length, sample rate, channels and, for MP3, the bitrate. **Tags** lists every tag
(with Copy buttons), **Chapters** lists an audiobook's chapters and where each starts, and **Pictures** shows any
pictures, each with a **Save** button.
For MP3, FLAC, WAV, M4A and M4B, **Save without tags** saves a copy, named like `song-untagged.mp3`, without the
tags and pictures. The sound itself is copied unchanged, and an M4B keeps its chapters.
#### Example
In the Tone Generator, save a 2-second sine wave, then open the file here.
The table shows the format `WAV (PCM)`, length `0:02.00`, sample rate `48,000 Hz`, `1` channel and `16` bits a
sample, and there are no tags.
#### Good to know
Removing tags isn't offered for Ogg files, whose tags are woven into the file's structure. For M4A and M4B, it
removes the movie's tag boxes; tags kept inside a single track, which are rare, stay. An MP3's length
is exact when it has an Xing or Info header (most encoders add one) and otherwise estimated from its bitrate, which
is wrong for files with a changing bitrate.
A sound can carry other information, such as background noise or speech, that no tag remover touches.
### Tuner
https://toolbox.thoughtasylum.com/tuner/
Tune a guitar, ukulele, violin or voice with your microphone: see the note, its frequency and how sharp or flat it is. Nothing leaves your device.
#### What it's for
Tune an instrument or check your singing against the right note, with nothing to install. It listens through
your microphone, finds the pitch of what it hears, and shows the nearest note and how far off it is in cents
(hundredths of a semitone).
For example, when your guitar has gone out of tune before a practice, play each open string in turn and turn the
peg until the needle sits in the middle and turns to the accent colour.
#### How to use it
Press **Start listening** and allow the microphone when the browser asks. Play or sing one note at a time: the
big letter is the nearest note with its octave (`E2` is a guitar's low E string), and the line below gives the
frequency and whether it's sharp (too high) or flat (too low). The needle moves right when sharp and left when
flat, and is coloured once it's within 5 cents. Screen readers hear the note when it changes.
**Concert pitch** sets the A above middle C (A4), normally 440 Hz; some orchestras use 442 and some players 432.
It's remembered in this browser.
#### Example
Open the Tone Generator on another device, set the frequency to `A4` and play it near the microphone. The tuner
shows `A4`, `440.0 Hz · in tune`, with the needle in the middle. Change **Concert pitch** to `442` and it reads
`8 cents flat`.
#### Good to know
It reads one note at a time: a strummed chord or a noisy room gives an unsteady reading or none. It hears from
about 40 Hz (a bass guitar's low E) to 2,000 Hz; very low notes on a laptop microphone can read an octave high.
The sound is only analysed on this page and never recorded or sent anywhere.
### Loudness Meter
https://toolbox.thoughtasylum.com/loudness/
Measure a file's integrated loudness in LUFS, loudness range and true peak, compare with podcast and streaming targets, and normalise. Nothing is uploaded.
#### What it's for
Check that a recording is the loudness the place it's going expects. Streaming services, podcast apps and
broadcasters turn every file up or down to the same loudness, measured in LUFS (loudness units relative to full
scale) by the ITU-R BS.1770 standard; a file mixed far off their target gets turned down and sounds flat, or
turned up and loses its peaks.
For example, when you've edited a podcast episode, open the export here to see whether it's near −16 LUFS with
peaks under −1 dBTP, and save a corrected copy if not.
#### How to use it
Choose a sound file (WAV, MP3, M4A, Ogg or FLAC, as far as this browser plays them), or drop it on the page. It's
measured at once:
- **Integrated loudness**: the whole file, with silence and very quiet parts left out as the standard says.
- **Loudness range**: how much the loudness varies (EBU Tech 3342), in loudness units (LU).
- **Loudest 3 seconds** and **Loudest 0.4 seconds**: the short-term and momentary maximums.
- **True peak**: the highest point including between samples, found by oversampling four times.
The second table compares it with the usual targets. To fix it, choose a **Target** (remembered in this browser)
and **Save at this loudness**: you get a WAV, or an AAC `.m4a` or MP3 if you choose one beside the button, turned up or
down by the difference. If turning it up would push
the true peak above −1 dBTP, it's turned up only as far as that allows, and the message says so.
#### Example
In the Tone Generator, save a `1000` Hz sine wave for `5` seconds at volume `10`%, and open it here.
It reads `−23.0 LUFS`, sample peak `−20.0 dBFS`, and is on target for EBU R 128 but `7.0 LU too quiet` for
podcasts. With the target at −16, **Save** turns it up 7.0 dB.
#### Good to know
It changes the volume only: it doesn't compress or limit, so a sound with sharp peaks may not reach a loud target
without going over −1 dBTP. Use an audio editor's limiter for that, then measure again.
A mono file is measured as one channel, as the standard says, which reads 3 LU lower than the same sound as
stereo; that's why some podcast guidance gives −19 LUFS for mono. Sound is measured at 48 kHz, so the saved WAV
is 48 kHz.
### Audiobook Maker
https://toolbox.thoughtasylum.com/audiobook-maker/
Combine MP3, M4A or WAV chapter files into one M4B audiobook with chapter marks, title, author, narrator and cover art. Nothing is uploaded.
#### What it's for
Turn a set of recorded chapters into one audiobook file. An M4B is AAC sound (the format of an `.m4a`) with a
chapter list, so a listener can skip from chapter to chapter, and an audiobook player remembers where they stopped.
This joins the chapters in the order you choose, marks where each starts, and adds the book's title, author,
narrator and cover.
For example, when you've recorded a short book or a course one chapter at a time, choose all the chapter files
here and save a single `.m4b` for Apple Books or another audiobook app.
#### How to use it
Choose the chapter files (MP3, WAV, M4A, FLAC or Ogg, as far as this browser plays them), several at once, or drop
them on the **Chapter files** box. They're sorted by file name as they're added, so `2` comes before `10`. Each
chapter's title starts as the file's own title tag, or its name without the extension and a leading number
(`03 - The Storm.mp3` becomes `The Storm`); change any title, and use the arrows to reorder.
Fill in the book's details, and choose a JPEG or PNG for the cover if you like (drop it on its own box). **Sound**
and **Quality** are remembered in this browser: mono at 64 or 96 kbit/s suits speech; choose stereo for music.
**Make the audiobook** re-encodes every chapter, one after another, and saves `
.m4b`.
#### Example
In the Tone Generator, save a sine wave at `440` Hz for `3` seconds and another at `660` Hz for `2` seconds. Choose
both files here, type `Tones` as the book title, and **Make the audiobook**.
The chapters are `tone-440hz` and `tone-660hz`, and it saves `Tones.m4b`: "2 chapters, 0:05 long". Open it in the
Audiobook Splitter or Audio Tags to see the second chapter starting at `0:03`.
#### Good to know
Making AAC needs a browser that can encode it (Chrome, Edge or Safari; not Firefox). The sound is re-encoded, so
start from the best copies you have, not MP3s made from MP3s. Every chapter is resampled to 44.1 kHz, and a chapter
is held in memory while it's encoded, so very long chapters (several hours each) may be too big for the browser.
The chapter list is written both in Apple's form and in the form most other players read (Nero's), but players
differ: check the result in the app you'll use. The narrator is stored as the composer, where most apps show it.
It doesn't check loudness or levels: use the Loudness Meter on each chapter first.
### Audiobook Splitter
https://toolbox.thoughtasylum.com/audiobook-splitter/
Split an M4B audiobook into one file per chapter, as M4A copied without re-encoding or as MP3, with titles and track numbers. Nothing is uploaded.
#### What it's for
Break an audiobook into one file a chapter. Some players, car stereos and older devices don't play M4B or don't
show its chapters, and it's easier to share or edit one chapter than a whole book.
For example, when your car only plays a folder of numbered tracks, split the book here and copy the chapters to a
USB stick.
#### How to use it
Choose an `.m4b` (or an `.m4a` or `.mp4` with chapters), or drop it on the page. The chapters are listed with where
each starts. They're read from Apple's chapter track, or from Nero's chapter list when there's no track.
**Save the chapters (ZIP)** saves `-chapters.zip` with one numbered file a chapter. **M4A** (remembered in
this browser) copies the sound exactly as it is, which is quick and loses nothing; each file keeps the book's tags
and cover, with the chapter's title as its title, the book's title as the album, and its number as the track.
**MP3** decodes and re-encodes each chapter at 96 kbit/s, for players that only take MP3.
#### Example
Make `Tones.m4b` as in the Audiobook Maker's example, and open it here.
It lists `0:00 · tone-440hz` and `0:03 · tone-660hz`, and saves `Tones-chapters.zip` holding `01 tone-440hz.m4a` and
`02 tone-660hz.m4a`.
#### Good to know
A chapter is cut at the block of sound (a few hundredths of a second) where it starts, so it may begin a moment
early or late. The MP3s are named by chapter but carry no tags, and re-encoding loses a little quality. Books with
DRM (copy protection), such as Audible's `.aax` files, can't be split. Fragmented MP4 files aren't read. The whole
book is held in memory, so a very large one may be too much for a phone.
### Sound Effect Generator
https://toolbox.thoughtasylum.com/sound-effects/
Make short random sound effects for alerts and automations. Each comes from a seed number, so the same seed gives the same sound. Save as WAV or MP3. Free.
#### What it's for
Make short sound effects, about two thirds of a second long, each built from a number called a seed. The same seed always gives the same sound, so a sound you like can be made again from its number alone. It's a browser version of [SEG](https://github.com/sylumer/seg), a command line tool for the Mac, and a seed gives the sound SEG makes.
For example, when your automations all end with the same system beep, play random sounds until you have one for each, note their seeds, and save each as a WAV file for the automation to play.
#### How to use it
**Random sound** picks a seed, puts it in the **Seed** box and plays it; press it again for another.
**Play this seed** plays the number in the box, and **Save** saves the sound as WAV, MP3 or AAC, named `seg-`
with the format's extension. The
message names the seed and what it made, such as "Pulse tone at 728 Hz with 2 harmonics, noise, echo,
distortion."
Seeds are whole numbers from −2,147,483,648 to 2,147,483,647; bigger ones wrap round, as in SEG, and −1 means a
random one. **Change the sound** keeps the seed's character and changes one part, like SEG's `-c` settings file:
**Pitch** sets the base pitch, **Reverb room** the size of the reverb, **Echo** the longest echo time (the seed
picks a time between half that and it), and **Drive** the distortion. Reverb, echo and distortion only change a
seed that has them. **Volume** scales both playing and saving; at 100% the file is as loud as SEG makes it.
**Copy a link** keeps the seed and settings.
#### Example
Enter this seed and press **Play this seed**:
```
12345
```
The message reads "Seed 12345: Pulse tone at 728 Hz with 2 harmonics, noise, echo, distortion." Running
`seg 12345` in SEG plays the same sound.
#### Good to know
Every sound is mono, 44.1 kHz and 0.7 seconds, the last part of it silent, as in SEG 1.0.0. The samples are worked out in a different way from SEG's, so a saved file differs from SEG's by tiny amounts you can't hear, and a later version of SEG may make different sounds from the same seed. MP3 and AAC lose a little detail, as compressed formats do; WAV keeps every sample.
#### Link with input
`https://toolbox.thoughtasylum.com/sound-effects/#sg-seed=…&sg-f0=…&sg-reverb=…&sg-echo=…&sg-drive=…&sg-vol=…` fills these fields in order (values URL-encoded; leave out any to keep its default) and runs the tool:
- `sg-seed` (Seed (blank: random)): text
- `sg-f0` (Pitch (Hz)): a number (min 0, step any)
- `sg-reverb` (Reverb room): a number (min 0, step any)
- `sg-echo` (Echo (seconds)): a number (min 0, step any)
- `sg-drive` (Drive): a number (min 0, step any)
- `sg-vol` (Volume (%)): a number (min 0, max 100)
It makes sound, so there's no text result to read.
- `#sg-msg`: the status line, with errors and summaries
### Podcast Feed Builder
https://toolbox.thoughtasylum.com/podcast-feed/
Make a podcast RSS feed (feed.xml) with Apple's podcast tags for a private or personal podcast: drop sound files to add episodes, or edit a feed. Free.
#### What it's for
Write the RSS feed that turns a folder of sound files on a web server into a podcast you can subscribe to in any podcast app. The feed is a single XML file listing the show and its episodes, with the tags Apple Podcasts and most other apps read.
For example, when you turn articles into speech or record notes for yourself, put the sound files on your own site, drop them here to make the episodes, upload the `feed.xml` beside them, and add its address to your podcast app with "Follow a show by URL" (or your app's equivalent).
#### How to use it
Fill in the **Podcast** details; the feed updates as you type. To change an existing feed, **Open a feed to edit**
(or drop it on that box) and its details and episodes are filled in.
For episodes, first set **Where the sound files will be**, the address of the folder they'll be uploaded to,
ending in `/`. Then choose sound files, or drop them on the **Sound files** box: each becomes an episode with the
address, file size, type and length filled in, the title from the file's tags (or its name) and the date it was
last changed. Changing the folder address afterwards updates those episodes. **Add an episode by hand** adds a
blank one. The files themselves are never uploaded; only their details are read.
The message lists anything a podcast app may refuse, such as a missing address or cover picture. **Save
feed.xml** saves the feed, newest episode first; **Copy** copies it.
#### Example
Set **Title** to `Reading List`, **Description** to `Articles read aloud.` and the cover picture address to
`https://example.com/cover.jpg`, then **Add an episode by hand** and give it the title `First episode`, the
address `https://example.com/audio/ep1.mp3` and a file size of `1048576`. The feed's episode reads:
```
-
First episode
https://example.com/audio/ep1.mp3
…
```
with today's date in `pubDate`, and the message reads "A feed with 1 episode."
#### Good to know
This writes the feed only: hosting the files and the feed is up to you, and an app can only reach them at public (or, for a private feed, unlisted) addresses. Anyone with the feed's address can listen. Each episode's GUID, the identifier apps use to tell episodes apart, is its address unless you give one, so moving a file makes apps see a new episode. Opening a feed keeps the tags this tool knows and drops others, such as chapters, transcripts, seasons and episode pictures. Apple Podcasts has its own extra rules for listing a show publicly; check them before submitting.
### Sound Level Meter
https://toolbox.thoughtasylum.com/sound-meter/
Measure sound level with your microphone: live dBFS, an A-weighted dB estimate with your own calibration offset, and peak hold. Nothing is recorded.
#### What it's for
See roughly how loud it is where you are, using your microphone. It shows the level of the sound in dBFS (decibels
relative to the loudest signal the microphone input can carry), an estimate in dB(A) (decibels weighted to match
how the ear hears quiet and high or low sounds) and the highest level so far.
For example, when you want to compare a quiet room with a noisy one, or see whether a fan got louder, start
measuring in each place and compare the dB(A) figures and the highest level.
#### How to use it
Press **Start measuring** and allow the microphone. The big number is the A-weighted estimate in dB(A), the
smaller one is the unweighted level in dBFS, and the bar follows the dBFS level. Readings use the last sixth of a
second. **Highest dB(A)** and **Highest dBFS** keep the loudest readings since you started; **Reset highest** clears them.
The **Calibration offset** is added to the A-weighted level in dBFS to give dB(A). Every microphone and device
has a different offset, so to get closer, hold a reference sound level meter beside the microphone, play a steady
sound, and change the offset until the two read the same. The offset is remembered in the browser.
#### Example
Press **Start measuring**, leave the offset at 90, and say "aaah" at a steady volume about 30 cm from your
device. The dBFS figure settles at some value below 0 (for example −30) and the dB(A) estimate shows that figure
plus 90 and the A-weighting (for example 60). Move closer and both rise together.
#### Good to know
This is an estimate, not a calibrated meter: phones and laptops differ by 10 dB or more, and without a reference
meter the dB(A) figure is a guess. Browsers and microphones may limit very loud sound or reduce low
frequencies, and cheap microphones can't show levels near the top of the range. The page turns off the
browser's echo cancelling, noise reduction and automatic gain, but some devices apply their own. The weighting
is the A curve only, with no C or Z curves, and the reading isn't suitable for checking noise limits at work or
hearing safety. Nothing is recorded, stored or sent anywhere; closing the page or choosing **Stop** releases the
microphone.
### Spectrogram
https://toolbox.thoughtasylum.com/spectrogram/
See the spectrogram of any audio to find hidden images, or turn text or a picture into a sound that draws it. Free, in your browser.
#### What it's for
Turn text or a picture into a sound that draws it in a spectrogram, a chart of which frequencies a sound contains over time, and draw the spectrogram of any sound. Musicians have hidden pictures in their tracks this way, and audio puzzles often do too.
For example, when a puzzle gives you a strange-sounding audio file, open it under **See a sound's spectrogram** to look for writing.
#### How to use it
Under **Draw into a sound**, type text or choose an image (or drop one on its box), then the length and the range of frequencies to draw in (remembered), and choose **Make the sound**. Bright parts become loud tones; tick **Dark parts are loud** for a dark drawing on a white background. You can play the sound, download it as a WAV, and see its spectrogram below.
Under **See a sound's spectrogram**, choose a sound file (WAV, MP3 and most others the browser plays) and the highest frequency to show. Time runs left to right and frequency bottom to top; louder is brighter.
Under the picture, **Colours** switches between heat, greyscale and print (dark on white, for paper); **Frequency scale** spreads frequencies evenly or by pitch (logarithmic, which shows speech and music in more detail at the bottom); **Range** sets how far below the loudest part still shows, so a smaller range hides background noise and a larger one shows quiet detail; and **Time and frequency scales** adds labelled axes. These are remembered, and change the picture without reading the sound again. **Save PNG** saves the picture as shown, at full resolution, and **Copy image** copies it.
#### Example
Keep the text as:
```
HELLO
```
and the default 5 seconds from 2,000 to 10,000 Hz, and choose **Make the sound**. It sounds like a hiss, and the
spectrogram shows `HELLO` in orange and yellow.
#### Good to know
Text is drawn up to 80 rows high and images 96 rows, between 1 and 30 seconds. Compressing the sound to MP3 or AAC can blur or remove the highest frequencies, so keep drawings below about 15,000 Hz if the file will be converted. Sounds over 10 minutes aren't drawn. Loud sounds near the drawing's frequencies hide it.
## Ciphers
### Caesar / ROT13
https://toolbox.thoughtasylum.com/caesar/
Encode and decode Caesar ciphers, ROT13, ROT5, ROT18 and ROT47, or brute-force every shift ranked by how English it reads. Free, in your browser.
#### What it's for
Shift every letter a fixed number of places along the alphabet, the cipher Julius Caesar used, or apply one of the ROT variants. ROT13 is the shift of 13 that hides spoilers and puzzle answers, since doing it twice gives back the original.
For example, when a puzzle or geocache gives you a line of scrambled letters, paste it in and look at the list of every shift: the one that reads as English is at the top.
#### How to use it
Type or paste text and the result appears as you type. For Caesar, choose the shift and whether to encrypt (shift forward) or decrypt (shift back); the cipher and shift are remembered. ROT5 shifts only digits, ROT18 does ROT13 and ROT5 together, and ROT47 rotates every printable ASCII character, so punctuation changes too.
**Every shift** lists all 25 Caesar shifts of your text, ranked by how much each looks like English, with the best marked. Choose a shift's name to use it above; each has a Copy button.
#### Example
Paste this into **Text**:
```
Wkh txlfn eurzq ira
```
**Every shift** puts *Shift 23 — best* at the top, reading `The quick brown fox`. Shifting forward 23 is the same
as shifting back 3, Caesar's own key.
#### Good to know
Only the letters A to Z shift; accented letters, digits (except in ROT5 and ROT18) and punctuation are left as they are. The ranking judges letter frequencies and common words, so very short text can rank a wrong shift first. A Caesar shift is a puzzle, not protection: anyone can undo it in seconds.
#### Link with input
`https://toolbox.thoughtasylum.com/caesar/#cz-mode=…&cz-k=…&cz-dir=…&cz-in=…` fills these fields in order (values URL-encoded; leave out any to keep its default) and runs the tool:
- `cz-mode` (Cipher): one of `caesar` (Caesar (letters)), `rot5` (ROT5 (digits)), `rot18` (ROT18 (ROT13 and ROT5)), `rot47` (ROT47 (printable ASCII))
- `cz-k` (Shift): a number (min 1, max 25)
- `cz-dir` (Direction): one of `1` (Encrypt (shift forward)), `-1` (Decrypt (shift back))
- `cz-in` (Text): text, may be several lines
The result shows in these elements:
- `#cz-out` (Result): its value
- `#cz-all` (Every shift): its text
### Classical Ciphers
https://toolbox.thoughtasylum.com/classic/
Encrypt and decrypt Vigenère, Playfair, Bifid, Four-square, Porta, Atbash, Rail Fence, AMSCO, ADFGVX, Pigpen and 20 more as you type. Free.
#### What it's for
Encrypt and decrypt with the classical pencil-and-paper ciphers, from simple letter swaps to the field ciphers
of the World Wars.
- When you're solving a puzzle, escape room or geocache and know (or suspect) which cipher was used.
- When you're setting one, and want to check that your ciphertext decodes as you meant.
- When you're learning how these ciphers work: the square, alphabet or zigzag the cipher uses is shown under the result.
#### How to use it
Choose a cipher and a direction, then type in **Input**: the output changes as you type. The fields each cipher
needs appear beside it (a keyword, Affine's two numbers, the number of rails, Bacon's alphabet), and they are
remembered. **Use output as input** moves the result back to the top and flips the direction, to check a round trip.
- **Substitution:** Atbash (A↔Z, B↔Y), Affine (multiply and shift), keyword substitution, keyed Caesar (a shift
along a keyword alphabet), Polybius square (each letter as row and column), Bacon (each letter as five A's and
B's) and Pigpen (drawn as symbols).
- **Polyalphabetic:** Vigenère, Beaufort and Autokey shift each letter by the next letter of a key; Gronsfeld is
Vigenère with a number as the key; Porta swaps the two halves of the alphabet, shifted by each pair of key
letters, so the same key encrypts and decrypts. A **one-time pad** shifts by a random key as long as the text:
**Make a pad** writes one into the keyword box.
- **Two letters at a time:** Playfair uses one 5 × 5 square, Four-square two keyed squares (keyword and second
keyword).
- **Fractionating:** Bifid and Trifid split each letter into its coordinates in a square or a 3 × 3 × 3 cube and
mix them, a **period** of letters at a time; Nihilist adds the Polybius numbers of the text and of a second
keyword.
- **Transposition:** Rail Fence writes the text in a zigzag; columnar transposition writes it in rows and reads
the columns in the keyword's alphabetical order; double transposition does that twice, with two keywords;
AMSCO fills the rows with one and two letters in turn; the route cipher reads the rows in a clockwise spiral;
the scytale writes the text round a rod of so many turns.
- **ADFGX** and **ADFGVX** combine a 5 × 5 or 6 × 6 square with a columnar transposition.
#### Example
Choose **Vigenère**, keep the keyword `LEMON`, and type:
```
Attack at dawn
```
The output is `Lxfopv ef rnhr`. Choose **Use output as input** and it decrypts back to `Attack at dawn`.
#### Good to know
Playfair and Polybius merge J into I, and Playfair puts an X between doubled letters and on the end of an odd
number of letters (a Q if the letter is X), so decrypting shows those extra letters. Playfair, Polybius, Bacon,
ADFGVX and Pigpen work on letters only and drop punctuation; Rail Fence and columnar transposition move every
character you type, spaces included, so leave the spaces out for the traditional form. Bacon decrypts A's and
B's, or, for any other text, reads lower case as A and upper case as B, the way Bacon hid messages in type.
Pigpen only encrypts, as its symbols can't be typed. The 5 × 5 squares (Playfair, Four-square, Bifid, Nihilist,
ADFGX) merge J into I; Trifid's cube uses `+` as its 27th symbol; Four-square and the spiral route pad an odd or
short text with X. The newer transpositions work on letters only. A one-time pad is unbreakable only if its pad is
truly random, as long as the message and never used again; the keyword box is remembered in this browser, so
clear it afterwards. None of the other ciphers protects anything today.
#### Link with input
`https://toolbox.thoughtasylum.com/classic/#cl-cipher=…&cl-dir=…&cl-key=…&cl-key2=…&cl-a=…&cl-b=…&cl-shift=…&cl-period=…&cl-width=…&cl-rails=…&cl-bacon=…&cl-in=…` fills these fields in order (values URL-encoded; leave out any to keep its default) and runs the tool:
- `cl-cipher` (Cipher): one of `atbash` (Atbash), `affine` (Affine), `keyword` (Keyword substitution), `keyedcaesar` (Keyed Caesar), `polybius` (Polybius square), `bacon` (Bacon), `pigpen` (Pigpen), `vigenere` (Vigenère), `beaufort` (Beaufort), `autokey` (Autokey), `gronsfeld` (Gronsfeld), `porta` (Porta), `otp` (One-time pad), `playfair` (Playfair), `foursquare` (Four-square), `bifid` (Bifid), `trifid` (Trifid), `nihilist` (Nihilist), `rail` (Rail Fence), `columnar` (Columnar transposition), `double` (Double transposition), `amsco` (AMSCO), `route` (Route (spiral)), `scytale` (Scytale), `adfgx` (ADFGX), `adfgvx` (ADFGVX)
- `cl-dir` (Direction): one of `enc` (Encrypt), `dec` (Decrypt)
- `cl-key` (Keyword (a number for Gronsfeld; the pad for a one-time pad)): text
- `cl-key2` (Second keyword): text
- `cl-a` (a (multiplier)): one of `1`, `3`, `5`, `7`, `9`, `11`, `15`, `17`, `19`, `21`, `23`, `25`
- `cl-b` (b (shift)): a number (min 0, max 25)
- `cl-shift` (Shift): a number (min 0, max 25)
- `cl-period` (Period (0 for the whole text)): a number (min 0, max 50)
- `cl-width` (Columns (turns of the rod)): a number (min 2, max 30)
- `cl-rails` (Rails): a number (min 2, max 20)
- `cl-bacon` (Alphabet): one of `26` (26 letters), `24` (24 letters (I = J, U = V))
- `cl-in` (Input): text, may be several lines
The result shows in these elements:
- `#cl-out` (Output): its value
- `#cl-msg`: the status line, with errors and summaries
### Image Steganography
https://toolbox.thoughtasylum.com/stego/
Hide a message or small file inside an image's pixels, optionally password-protected, and reveal it again. Steganography in your browser.
#### What it's for
Hide a message or a small file inside a picture so that the picture looks unchanged, then get it back out. The message is stored in the lowest bit of each pixel's red, green and blue, which changes each colour by at most one step in 256.
For example, when you're setting a puzzle and want the next clue hidden in a photo, or want to pass on a note that doesn't look like a secret at all.
#### How to use it
You can drop files onto each of the three file boxes as well as choosing them. Under **Hide**, choose a cover image (JPEG, PNG, WebP or anything else the browser opens): its room for hidden data is shown. Type a message or choose a file, add a password if you like, and choose **Hide in image**. You get a PNG to download. With a password, the message is encrypted with AES-256 before it's hidden.
Under **Reveal**, choose the PNG; any hidden message appears in the box, or a hidden file is offered to download. If it has a password, type it first, or type it and choose **Reveal** again.
#### Example
Choose any photo as the cover image, type this as the message and choose **Hide in image**:
```
The eagle lands at dawn.
```
Download the PNG, choose it under **Reveal**, and *Found a hidden message.* appears with the text. Add the
password `s3cret` when hiding and the message can't be read until you type it under **Reveal**.
#### Good to know
The result must stay a PNG, sent as a file. Anything that re-saves or converts the picture, such as most social networks and messaging apps, or exporting it as a JPEG, destroys the message. Room is about 3 bytes for every 8 pixels, so a 12-megapixel photo holds about 4.5 MB. Hiding is not encryption: anyone with this tool can find an unprotected message, so use a password for anything private. The hidden bits can be detected by statistical analysis, so this hides from people, not from forensics.
### Cipher Cracker
https://toolbox.thoughtasylum.com/crack/
Solve an unknown cipher: Caesar, Affine, Atbash, Vigenère, Beaufort, Rail Fence, cryptogram (substitution) and columnar transposition keys.
#### What it's for
Find the plain text of a ciphertext when you don't know the key, and often when you don't know the cipher. It tries every key of the simple ciphers, works out the likeliest keys of the polyalphabetic ones, and lists the results that look most like English.
For example, when a puzzle hands you a paragraph of gibberish with no other clue, paste it here before trying anything by hand.
#### How to use it
Paste the ciphertext; results appear as you type. It tries every Caesar shift and Affine key (which include Atbash), Vigenère and Beaufort with the four likeliest key lengths, and Rail Fence with 2 to 10 rails. The twelve most English-looking results are listed, best first, each with its cipher and key and a Copy button.
The line above the results gives the **index of coincidence**: about 0.067 for English or English rearranged, about 0.038 for random letters. A high value points to a single substitution or a transposition, a low one to a polyalphabetic cipher such as Vigenère, and then the likeliest key lengths are listed too.
**Try substitution and columnar transposition** runs two slower attacks: it solves a keyword substitution (any scrambled alphabet, the commonest puzzle cipher) by repeatedly swapping letters and keeping whatever reads more like English, and tries every column order of a columnar transposition up to 7 columns, and a search up to 10. It shows the best of each, with the alphabet or key it found. Leave the spaces between words in if the puzzle has them: the substitution attack then also checks the words against a dictionary, which makes it far more reliable.
#### Example
Paste this:
```
Lb ykw gzh jgcx bx wqoow, vl ziu dlr orzud ss llugc, mg oda vri nyh wh gmfvru, kd ank wpg kkr gi nqypvkkvgcw, vl ziu dlr wswer ss thtkoj, vl ziu dlr wswer ss aqktohhdlba.
```
The top result is *Vigenère, key DICKENS*: `It was the best of times, it was the worst of times…`
#### Good to know
Results are judged as English, so text in another language may rank wrongly. Vigenère and Beaufort need enough text: roughly 25 letters for every letter of the key, so a short message with a long key may not be found. Keys up to 20 letters are tried. The substitution attack needs about 100 letters to be reliable; with fewer it gets most letters right and the rest can be fixed by eye. The columnar attack works on letters only. Playfair, the fractionating ciphers and Enigma aren't attempted; use Classical Ciphers once you have a guess at the key.
#### Link with input
`https://toolbox.thoughtasylum.com/crack/#ck-in=…` fills these fields in order (values URL-encoded; leave out any to keep its default) and runs the tool:
- `ck-in` (Ciphertext): text, may be several lines
The result shows in these elements:
- `#ck-out`: its text
- `#ck-msg`: the status line, with errors and summaries
### Enigma Machine
https://toolbox.thoughtasylum.com/enigma/
A working Enigma I, M3 and M4 simulator with rotors I–VIII, reflectors, ring settings and plugboard. Encrypt and decrypt like Bletchley Park.
#### What it's for
A working copy of the Enigma machines Germany used in the Second World War: the Enigma I of the Army and Air Force, the Navy's M3 and the four-rotor M4. Enigma is its own inverse, so typing a ciphertext with the same settings gives back the message.
For example, when you're reading about Bletchley Park and want to decrypt a real wartime message with its published settings, or send a friend a message they can decode with the same machine.
#### How to use it
Choose the model, reflector, three rotors (and the M4's thin fourth rotor), the ring settings, the start position and any plugboard pairs. Settings are remembered. Ring settings and start position take letters (`AAA`) or numbers from 1 to 26 (`01 01 01`), left to right; on the M4, give four. Plugboard pairs are written like `AV BS CG`.
Type in **Input** and the output appears as you type, computed from the start position each time. The rotors' positions after the last letter are shown, and the lamp for the last letter lights. **Continue from here** makes those positions the new start and clears the input. **Letters only, in groups of five** drops everything but letters and groups the result the way operators sent it.
#### Example
With the default settings (Enigma I, reflector B, rotors I, II and III, rings and start `AAA`, no plugs), type:
```
HELLOWORLD
```
The output is `ILBDAAMTAZ` and the rotors show `A A K`. Type `ILBDAAMTAZ` instead and you get `HELLOWORLD`.
#### Good to know
Includes the middle rotor's double step, as the real machines had. Characters other than A to Z pass through unchanged and don't turn the rotors; operators spelled out numbers and wrote X for spaces. Enigma never encrypts a letter to itself, which was one of the weaknesses that let it be broken.
#### Link with input
`https://toolbox.thoughtasylum.com/enigma/#eg-model=…&eg-ref=…&eg-thin=…&eg-r0=…&eg-r1=…&eg-r2=…&eg-rings=…&eg-start=…&eg-plugs=…&eg-group=…&eg-in=…` fills these fields in order (values URL-encoded; leave out any to keep its default) and runs the tool:
- `eg-model` (Model): one of `I` (Enigma I (Army, Air Force)), `M3` (M3 (Navy)), `M4` (M4 (Navy, four rotors))
- `eg-ref` (Reflector): one of `A`, `B`, `C`, `B thin`, `C thin`
- `eg-thin` (Fourth rotor): one of `Beta`, `Gamma`
- `eg-r0` (Left rotor): one of `I`, `II`, `III`, `IV`, `V`, `VI`, `VII`, `VIII`
- `eg-r1` (Middle rotor): one of `I`, `II`, `III`, `IV`, `V`, `VI`, `VII`, `VIII`
- `eg-r2` (Right rotor): one of `I`, `II`, `III`, `IV`, `V`, `VI`, `VII`, `VIII`
- `eg-rings` (Ring settings): text
- `eg-start` (Start position): text
- `eg-plugs` (Plugboard pairs): text
- `eg-group` (Letters only, in groups of five): `1` to tick, empty to leave unticked
- `eg-in` (Input): text, may be several lines
The result shows in these elements:
- `#eg-out` (Output): its value
- `#eg-msg`: the status line, with errors and summaries
### Hidden Text
https://toolbox.thoughtasylum.com/hidden-text/
Find, decode and remove zero-width and other invisible Unicode characters hidden in text, or hide a secret message of your own.
#### What it's for
Hide a secret inside ordinary text using characters that don't show, and find characters like these in text you
receive. Invisible characters are also used to watermark text, to track where it was copied, and to slip hidden
instructions to AI tools.
- When you're setting a puzzle or sending a message that should look like something else.
- When you're checking text you've been sent, or copied from a web page, for anything hidden in it.
- When you need a clean copy of text without zero-width spaces, direction marks or other invisible characters.
#### How to use it
Under **Hide**, type the cover text and the secret; the text with the secret in it appears as you type, ready to
copy. Choose how it's hidden (remembered):
- **Zero-width characters** carry any text, as a run of zero-width spaces and non-joiners after the first character.
- **Unicode tag characters** carry only plain ASCII, and are used in "ASCII smuggling" against AI tools.
- **Variation selectors** carry any text in the fewest characters; they're placed after the first emoji, if there is one.
Under **Find and reveal**, paste text: it counts every invisible character, decodes any message hidden in the
three ways above, and gives the text with all of them removed. The emoji presentation selector (U+FE0F), part of
normal emoji, is kept.
#### Example
Type this as the cover text:
```
See you at the usual place
```
and `Gate code 4471` as the secret. The result looks the same as the cover text. Copy it, paste it into **Text to
check**, and it shows *Zero-width binary: Gate code 4471*.
#### Good to know
Some apps and websites strip invisible characters, which loses the secret, and some show them as boxes.
Hiding isn't encryption: anyone with a tool like this can read the message. The detector finds zero-width and
formatting characters, direction controls, tag characters and variation selectors, but not look-alike letters
from other alphabets; use the Character Inspector for those.
### Picture Alphabets
https://toolbox.thoughtasylum.com/picture-alphabets/
Turn text into pigpen, flag semaphore, signal flags, Hexahue, Braille or runes, and decode symbols by clicking them on a keyboard. Free.
#### What it's for
Write a message in an alphabet of symbols, or read one, for puzzles, geocaches, escape rooms and classroom
activities. The alphabets are:
- **Pigpen** (the masonic cipher): each letter is the shape of its cell in a grid or an X, some with a dot.
- **Flag semaphore**: the positions of two hand-held flags, as the reader sees the signaller.
- **Maritime signal flags**: the International Code of Signals' flag for each letter.
- **Hexahue**: Josh Cramer's colour alphabet, each character a block of six coloured squares. Letters use red,
green, blue, yellow, cyan and magenta once each; digits use white, grey and black; and it has `.` and `,` too.
- **Braille**, **Elder Futhark runes** and **Greek letters**: characters you can copy as text.
For example, when a geocache's clue is a row of pigpen symbols, choose Pigpen and click each symbol you see under
**Read symbols** to spell out the answer.
#### How to use it
Choose the **Alphabet** and type the **Text**; the symbols appear as you type. Pictures can be saved with
**Download SVG** (22 symbols to a row), and Braille, runes and Greek can be copied as text. Characters an
alphabet has no symbol for are shown as they are.
To read a message, click the matching symbols under **Read symbols** in order (with **Space** between words), and
the letters build up in **Reads as**, which you can edit. For Braille, runes and Greek you can instead paste the
symbols into **Text**, and what they read as appears below. The alphabet is remembered in the browser, and **Copy
a link to this input** keeps the alphabet and text.
#### Example
Choose **Try an example**, which writes `Meet at noon` in pigpen: M is a square open on the left with a dot,
E is a closed square, and T is a V on its side. Choose **Elder Futhark runes** instead and it's `ᛗᛖᛖᛏ ᚨᛏ ᚾᛟᛟᚾ`.
#### Good to know
Pigpen comes in several layouts; this is the common one (A–I in a grid, J–R in a dotted grid, S–V in an X and
W–Z in a dotted X). Runes and Greek are letter-for-letter swaps, not translations: C, K and Q share one rune and
one Greek letter, so they read back as k, and runes have no separate V or Y. Braille is uncontracted (grade 1),
with numbers and common punctuation. Semaphore and flags cover letters only, not their numeral signs. Hexahue
writes a space as an all-white or all-black block, which is left as a gap here; its other punctuation was never
fixed, so only `.` and `,` are drawn. The Hexahue chart follows dCode's (dcode.fr).
#### Link with input
`https://toolbox.thoughtasylum.com/picture-alphabets/#pa-kind=…&pa-in=…` fills these fields in order (values URL-encoded; leave out any to keep its default) and runs the tool:
- `pa-kind` (Alphabet): one of `pigpen` (Pigpen (masonic cipher)), `semaphore` (Flag semaphore), `flags` (Maritime signal flags), `hexahue` (Hexahue (colours)), `braille` (Braille), `runes` (Elder Futhark runes), `greek` (Greek letters)
- `pa-in` (Text): text, may be several lines
The result shows in these elements:
- `#pa-text` (In symbols): its value
- `#pa-msg`: the status line, with errors and summaries
### Visual Cryptography
https://toolbox.thoughtasylum.com/visual-crypto/
Split a word or picture into two images of random noise that reveal the secret only when laid on top of each other. Visual cryptography.
#### What it's for
Split a word or a black-and-white picture into two images that each look like random noise. Put one on top of the other and the secret appears, with no computer needed. This is Naor and Shamir's visual cryptography from 1994, and each share on its own reveals nothing at all.
For example, when you're making a puzzle or an invitation: print one share on paper and the other on a transparency, give them to two people, and the message only appears when they get together.
#### How to use it
Type the secret text, or choose **Black and white image** and pick a picture or drop one on the page (it's reduced to black and white at up to 240 pixels wide). The shares are made straight away; **New shares** makes a fresh random pair. Drag the slider to slide share B over share A and watch the secret appear when they line up. Download each share as a PNG, with clear rather than white pixels so a share printed on a transparency can be laid over the other.
**Pixel size** sets how many screen pixels each dot uses (remembered); larger is easier to line up by hand.
#### Example
Keep the text as:
```
SECRET
```
Drag the slider to the left: as share B reaches the left edge, `SECRET` appears in solid black on a grey speckle.
#### Good to know
Stacked, white areas are only half dark, so the secret shows as black on grey, not on white. Printed shares must be printed at exactly the same size and lined up precisely; a larger pixel size helps. Each share is twice the width and height of the secret in dots. Only two shares are made, and both are needed.
### Image Encryption
https://toolbox.thoughtasylum.com/image-cipher/
Encrypt a picture's pixels with a password into an image of noise and back, and see why ECB mode leaks the outline. Runs in your browser.
#### What it's for
Encrypt the pixels of a picture with a password, so the result is still a picture but shows only noise, and
decrypt it again. It also shows, side by side with proper encryption, why encrypting in ECB mode is a mistake.
- When you want to share a picture that only someone with the password can see, as an image rather than a file.
- When you're learning or teaching cryptography: the ECB picture shows its outline through the encryption.
#### How to use it
Choose an image (or drop or paste one) and type a password, pick a method (remembered), and choose **Encrypt**. You get a PNG to
download. To decrypt, choose that PNG, type the password and choose **Decrypt**: the method is read from the image.
- **AES** encrypts the red, green and blue of every pixel with AES-256 in counter mode. The result is noise.
- **Shuffle pixels** moves the pixels to positions set by the password. It hides the picture, but every colour is
still there, so it's not secure.
- **AES in ECB mode** encrypts each 16 bytes on its own. Identical blocks give identical results, so flat areas
stay flat and the outline shows. It's a demonstration and can't be decrypted here.
#### Example
Choose a picture with large flat areas, such as a logo or a screenshot of text, type this as the password:
```
pw
```
and choose **AES in ECB mode** and **Encrypt**: the shapes are still recognisable through the noise. Choose
**AES** and **Encrypt** with the same picture and nothing of it can be seen.
#### Good to know
The encrypted image must stay this PNG: converting or re-saving it destroys both the pixels and the details stored in the file that decryption needs. Transparency isn't encrypted, so the outline of a transparent image shows. The key comes from the password through PBKDF2 with 600,000 iterations, and the encryption isn't authenticated, so a wrong password gives noise rather than an error. Use Encrypt / Decrypt for a file that must stay private; this is for pictures that should still look like pictures.
### XOR Cipher
https://toolbox.thoughtasylum.com/xor/
XOR text, hex or Base64 with a repeating key, and crack single-byte and repeating-key XOR by scoring every key. Free, in your browser.
#### What it's for
Combine data with a key using XOR (exclusive or), the operation inside most modern ciphers, and break simple XOR encryption when the key is unknown. Repeating-key XOR turns up in capture-the-flag challenges, malware and badly written software.
For example, when a CTF challenge gives you a hex string "encrypted with a single byte", choose **Find a single-byte key** and read the answer.
#### How to use it
Choose what the input is (text, hex or Base64), what the key is (text or hex) and how to show the result. The result changes as you type, with the key repeated as often as needed. XOR is its own inverse: XOR the result with the same key to get the input back. These choices are remembered.
**Find a single-byte key** tries all 256 keys; **Find a repeating key** estimates the key length from how alike blocks of the input are, then finds each key byte. Both list the most text-like results, best first; choose a key's name to use it.
#### Example
With **Input is** set to Hex, paste:
```
674f4f5e0a474f0a4b5e0a5e424f0a4858434e4d4f0a4b5e0a44454544060a4b444e0a485843444d0a5e424f0a474b5a04
```
and choose **Find a single-byte key**. The top result is *Key 2a ("\*")*: `Meet me at the bridge at noon, and
bring the map.`
#### Good to know
Breaking assumes the plain text is English or similar text. Repeating keys need several times the key's length of input: a 7-byte key on 60 bytes can come out with a byte or two wrong, which shows as the odd wrong letter. Key lengths up to 40 bytes are tried. In text view, bytes that aren't printable ASCII show as `·`. A key that is truly random, used once and as long as the message, is a one-time pad and can't be broken.
### Bit-Plane Inspector
https://toolbox.thoughtasylum.com/bitplane/
View each bit plane of an image's RGB and alpha channels, extract LSB data and compare two images pixel by pixel. Steganalysis for CTFs, in your browser.
#### What it's for
See each bit of an image's colour channels on its own, pull out the data stored in the lowest bits, and compare two images pixel by pixel. Hidden messages and watermarks that are invisible in the picture often show up clearly in a single bit plane. Tools like this are a staple of capture-the-flag challenges.
For example, when a challenge gives you a PNG that "looks normal", step through its bit planes for a hidden picture, then extract the low bits to look for text.
#### How to use it
Choose an image, or drop one on the **Image** box. Use the list or the arrows to step through the full image and each bit of red, green, blue and alpha, from bit 7 (the most significant) to bit 0; set bits show white. Choose a second image under **Compare with** and pick **Differences from the second image** to see which pixels differ.
**Extract** reads the chosen bit of the channels you list (such as `RGB` or `BGR`), pixel by pixel along rows or down columns, into bytes. The first 256 bytes are shown in hex and as text; **Download .bin** saves them all. These settings are remembered.
#### Example
Hide a message with the Image Steganography tool and save the PNG. Choose that PNG here, keep `RGB`, bit 0, row
by row and most significant bit first, and choose **Extract**. The text starts:
```
TBX1
```
which is the Image Steganography tool's marker, followed by the message.
#### Good to know
PNGs are read exactly, bit for bit. Other images, and the rare PNGs this can't read itself (16-bit or interlaced), are decoded by the browser, so their lowest bits may differ slightly, and some privacy settings add noise to them. Only images the browser can open are supported.
### Number Codes
https://toolbox.thoughtasylum.com/number-codes/
Convert letters to numbers and back: A1Z26, tap code, phone keypad multi-tap and T9, Baudot ITA2, BCD and Gray code. Free, for puzzles, in your browser.
#### What it's for
Turn letters into the number codes that turn up in puzzles, escape rooms and geocaches, and turn codes back into
letters: each letter's place in the alphabet, the prisoners' tap code, the digits of an old phone keypad, the
five-bit Baudot code of teleprinters, and for numbers, binary-coded decimal and Gray code.
For example, when a clue reads `20-8-5 11-5-25`, choose A1Z26 under **Back to text** and paste it: it says `THE KEY`.
#### How to use it
Type text and every code appears at once, each with a Copy button. To decode, choose the code under **Back to
text** (remembered) and paste the coded text.
- **A1Z26** numbers the letters from A = 1 (A0Z25 from A = 0), with hyphens between letters and spaces between
words.
- The **tap code** gives each letter as its row and column in a 5 × 5 square, with K tapped as C; decoding takes
digit pairs or groups of dots (`.. ...`).
- **Phone keypad** multi-tap presses a key once per letter position (`44` is H, `0` a space); T9 gives one digit a
letter.
- **Baudot** (ITA2) gives each character five bits, with a shift to figures before digits and punctuation and
back to letters after.
- For a number, **BCD** gives each decimal digit four bits, and **Gray code** the reflected binary code, where
neighbouring numbers differ by one bit.
#### Example
Type this:
```
Hello world
```
A1Z26 is `8-5-12-12-15 23-15-18-12-4`, the tap code `23 15 31 31 34 / 52 34 42 31 14`, and multi-tap
`44 33 555 555 666 0 9 666 777 555 3`.
#### Good to know
T9 can't be decoded on its own, since one digit stands for three or four letters. Baudot bits are written with
the highest bit first (E is `00001`); some tables write them the other way round. Letters with accents are
coded without them, and characters a code has no symbol for are left out.
#### Link with input
`https://toolbox.thoughtasylum.com/number-codes/#nc-in=…` fills these fields in order (values URL-encoded; leave out any to keep its default) and runs the tool:
- `nc-in` (Text, or a number): text, may be several lines
The result shows in these elements:
- `#nc-out`: its text
## Data
### JSON Format
https://toolbox.thoughtasylum.com/json/
Format, repair and minify JSON, query with JSONPath, view a tree and copy paths, flatten to dot notation, or see its size and depth. Nothing is uploaded.
#### What it's for
Make JSON readable, make it compact, or explore it as a tree. It also checks that the JSON is valid and tells you where it isn't.
For example, when an API returns one enormous line of JSON, prettify it to read it, or use the tree to find one value deep inside a large response.
#### How to use it
Paste JSON, choose an indent (2 or 4 spaces, or tabs), then:
- **Prettify** lays it out with one value per line.
- **Minify** removes all unnecessary spaces and line breaks, for the smallest output.
- **Tree** shows it as a collapsible outline, with the size of each object and array. Use **Expand all** and
**Collapse all** to move around. Choose or tab to any value and its JSONPath (such as `$.items[2].name`) shows
under the buttons; **Copy path**, or pressing C, copies it, ready to use as a query.
- **Array to JSON Lines** turns an array into JSON Lines (also called NDJSON): each item compacted onto a line of
its own, the form logs, data exports and bulk APIs use. **JSON Lines to array** does the reverse, skipping blank
lines and naming the first line that isn't valid JSON.
- **Flatten** turns nested JSON into one object of paths and values, such as `"user.tags[0]": "admin"`, the form
translation files, environment settings and spreadsheets often want. **Unflatten** turns it back, and also reads
the `user.tags.0` form other tools write.
- **Size and structure** reports the size as written and minified, how deeply it nests, how many values of each
kind and keys it holds, the longest array and string, and which parts at the top take up the most space.
JSON that's almost right is repaired first, and the message says what was fixed: comments, trailing commas,
single-quoted strings, keys without quotes, and Python's `True`, `False` and `None`. Tick **Sort keys** to put
every object's keys in alphabetical order (remembered). Type a **JSONPath query** such as
`$.items[?(@.price < 10)].name` to keep only the matching values: `.name`, `['name']`, `[0]`, `[-1]`, `[*]`,
`[0:3]`, `..name` (at any depth) and filters with `==`, `!=`, `<`, `<=`, `>` and `>=` work.
If the JSON can't be repaired, the error message gives the line and column of the problem.
#### Example
Paste this and choose **Prettify**:
```
{"name":"Alice","tags":["admin","dev"],"active":true}
```
The result has each key on its own line, indented by 2 spaces. Delete the last `}` and try again: the tool
reports the error instead.
#### Good to know
Repair handles the common slips, not every mistake: a missing comma or bracket is still an error. The JSONPath support covers the everyday parts of the standard, not functions such as `length()`. Very large numbers may lose precision, as they do in JavaScript. Flatten writes a key that isn't a plain name (one with a dot or a space, or a number) in brackets, as `["x.y"]`, so that Unflatten gives back the same JSON.
#### Link with input
`https://toolbox.thoughtasylum.com/json/#js-indent=…&js-q=…&js-in=…` fills these fields in order (values URL-encoded; leave out any to keep its default) and runs the tool:
- `js-indent` (Indent): one of `2` (2 spaces), `4` (4 spaces), `tab` (Tab)
- `js-q` (JSONPath query (optional)): text
- `js-in` (JSON): text, may be several lines
The result shows in these elements:
- `#js-out` (Result): its value
- `#js-msg`: the status line, with errors and summaries
### XML Format
https://toolbox.thoughtasylum.com/xml/
Format or minify XML, test XPath queries, and convert XML to JSON and back. Keeps comments, CDATA and namespaces. Nothing you paste is uploaded.
#### What it's for
Lay out XML so it's readable, or squash it onto one line. It also checks that the XML is well formed and shows the parser's error if it isn't.
For example, when a config file, SOAP response, RSS feed or SVG arrives as one long line, prettify it to see its structure.
#### How to use it
Paste XML, choose an indent (2 or 4 spaces, or tabs), and choose **Prettify** or **Minify**. Comments, CDATA sections, processing instructions and namespace declarations are kept.
Type an **XPath query**, such as `//book[price < 10]/title` or `count(//book)`, and Prettify shows only what it picks out: elements, attribute values, text or a single number. Namespace prefixes declared in the document can be used in the query.
**XML → JSON** turns elements into objects, attributes into keys starting `@`, text into `#text` (or the whole value, for an element with nothing else), and repeated elements into lists. **JSON → XML** does the reverse with the same rules, so the two round-trip.
#### Example
Paste this and choose **Prettify**:
```
AliceBobSee you soon
```
Each child of `` goes on its own indented line. `` stays on one line, because it contains text and
adding line breaks would change that text.
#### Good to know
Elements that contain text are never re-wrapped, so mixed content such as XHTML paragraphs stays on one line. Whitespace-only text between elements is removed. XML → JSON gives every value as a string, since XML has no numbers or booleans. XPath is the browser's own XPath 1.0.
#### Link with input
`https://toolbox.thoughtasylum.com/xml/#xm-indent=…&xm-q=…&xm-in=…` fills these fields in order (values URL-encoded; leave out any to keep its default) and runs the tool:
- `xm-indent` (Indent): one of `2` (2 spaces), `4` (4 spaces), `tab` (Tab)
- `xm-q` (XPath query (optional)): text
- `xm-in` (XML): text, may be several lines
The result shows in these elements:
- `#xm-out` (Result): its value
- `#xm-msg`: the status line, with errors and summaries
### Code Format
https://toolbox.thoughtasylum.com/code/
Minify or beautify HTML, CSS, JavaScript, SQL and SVG, or convert HTML and SVG to React JSX (className, style objects). Nothing is uploaded.
#### What it's for
Make code smaller, or make squashed code readable again, for HTML, CSS, JavaScript, SQL and SVG, or turn HTML and
SVG into JSX for React.
- When you're putting a snippet into a page, an email template or a bookmarklet and want it as small as it can be.
- When you're moving a snippet of HTML, or an SVG icon, into a React component.
- When you're reading minified code from a website or a build, or a query logged on one long line, and want it laid
out with one statement per line.
#### How to use it
Choose the language and an indent (2 or 4 spaces, or tabs), paste the code, then:
- **Prettify** lays it out with line breaks and indents, using js-beautify for HTML, CSS and JavaScript, and
sql-formatter for SQL. SVG is laid out as XML Format does it, keeping comments.
- **Minify** removes comments and unneeded whitespace. JavaScript also goes through Terser, which shortens local
names and simplifies the code. SVG goes through SVGO, which also rounds numbers and simplifies shapes. In HTML,
`