ASCII art is one of the few visual styles that still works inside plain text. It can sit at the top of a README, print during a CLI startup, mark a generated file, or make a terminal demo easier to recognize in a screenshot. The trick is restraint: the banner has to read quickly, copy cleanly, and survive the places where text gets wrapped, trimmed, or pasted into markdown.

That is where an ASCII Art Generator is useful. Instead of installing a font package, guessing line breaks, and fixing spacing by hand, you type the label once, pick a font, and copy the output. For most practical uses, the best ASCII art is not the biggest one. It is the one that keeps its shape when someone views it on GitHub, in a terminal at 100 columns, or inside a code comment.

What an ASCII Art Generator Is Good For

The best use cases are places where plain text already belongs. A CLI splash screen is the obvious one: users run a command, see the product name, and know they launched the right tool. A short README banner can also work when the project has a terminal-heavy identity. Generated files are another good fit. A small header can say "AUTO GENERATED" more visibly than a normal comment.

The weak use cases are just as important. Do not use ASCII art for a long paragraph, a legal notice, or anything that must be read by screen readers as normal prose. A banner is decoration plus identity. The actual instructions should still appear as regular text below it.

I tested the browser generator with short product names, version labels, and release codenames. Four to eight characters worked best. Once I pushed beyond about 12 characters in a large font, the result started to depend too much on the viewer's line width. For a README, that usually means the banner looks good on your laptop and breaks for someone reading on a narrower window.

A Real Input and Output Example

Here is a real example using the Toolora generator's Standard font. The input string is simple:

Toolora

And the output is:

----- /--\  /--\ |     /--\ |---\   /\
  |  |    ||    ||    |    ||    | /  \
  |  |    ||    ||    |    ||---/ /----\
  |  |    ||    ||    |    ||  \  |    |
  |   \--/  \--/ |---- \--/ |   \ |    |

That output is usable because it is five rows tall, contains only plain characters, and stays readable even when copied into markdown. It is not a logo replacement. It is a text-native marker that says, "you are in the right project."

If you want to reproduce it, open the Toolora ASCII Art Generator, enter Toolora, choose Standard, keep alignment on Left, and copy the result. The same input in a heavier block font can be better for a terminal welcome screen, but it is usually too dense for a README heading.

Settings That Actually Change the Result

Font choice matters more than color, because the output will often be viewed in someone else's theme. Standard fonts are easier to scan in code comments and docs. Big fonts work when the output stands alone, such as the first lines of a CLI. Slanted fonts can look good in screenshots, but they are less readable when the word contains many narrow letters like I, J, or L.

Alignment should match the destination. Left alignment is safest for markdown, source comments, and changelog headers. Center alignment can look polished in terminal startup output if you know the terminal width. Right alignment is rare, but it can make sense for generated reports where the banner sits inside a fixed-width frame.

Width caps are the setting people skip until a banner breaks. ASCII letters do not wrap like prose. If the text wraps in the middle of a letter, the shape is gone. A practical rule is to test the output at 80 columns for terminals and around 100 to 120 columns for README content. If the banner cannot fit, shorten the text before trying to force it.

Unsupported characters are another quiet source of broken output. Many generators are safest with A-Z, digits, spaces, and basic punctuation. For project names with emoji, accents, or symbols, make a plain ASCII version for the banner and keep the exact brand spelling in the normal heading below.

Sharing ASCII Art Without Making It Heavy

The main advantage of ASCII art is that it is text. Keep it that way when possible. A five-line banner in a README adds only a few hundred bytes, can be copied from the page, and works in dark mode without extra assets.

There are times when an image export makes sense, such as a social preview, a blog cover, or a product screenshot. If you turn the banner into a raster image, compress it like any other visual asset. Google's WebP compression study reported that WebP lossy images were 25-34% smaller than comparable JPEG files at equivalent SSIM quality, based on a test set of 900,000 web images (Google Developers WebP study). That number does not mean every ASCII screenshot should become WebP, but it is a good reminder: once plain text becomes pixels, file format matters again.

For markdown and terminal use, the better optimization is simpler: remove trailing spaces only if they are not part of the letter shape, keep the block inside a fenced code section, and avoid tabs. Tabs render differently across editors. Spaces are boring, which is exactly what you want here.

A Simple Workflow for READMEs and CLI Banners

Start with the destination, not the font. For a README, choose a short name, generate it in Standard, paste it into a fenced text block, and preview it on GitHub or your docs site. Put a normal H1 below or above it so search engines, screen readers, and skim readers still get the actual project name.

For a CLI, print the banner only where it helps. A startup command, --version, or an interactive welcome screen can carry a banner. A command that runs inside scripts should stay quiet unless the user asks for human-readable output. Nobody wants a huge banner in a CI log when they are trying to find the error line.

For generated files, use a compact banner and pair it with a clear warning:

// AUTO GENERATED
// Do not edit this file by hand.

That plain text warning is more important than the art. The art just makes the warning harder to miss.

My default workflow is: draft the exact label, generate two font options, paste both into the real destination, then delete one. Looking at the banner inside the final context is faster than debating fonts in isolation. The ASCII Art Generator is useful because the loop is short: type, copy, paste, judge, repeat.

Made by Toolora · Updated 2026-05-29

Aspect ratio mistakes rarely look dramatic in the export dialog. They show up later: a product photo gets soft, a YouTube thumbnail loses the headline, a square avatar trims someone's chin, or a blog cover looks fine on desktop and cramped on mobile. The fix is not a better eye. The fix is doing the ratio math before touching the crop handles.

The Toolora aspect ratio calculator is useful because it keeps the decision concrete: start with the current width and height, choose the dimension that cannot change, and let the other dimension fall out of the ratio. That is a small step, but it prevents the most common resize error: changing both numbers by feel.

Why ratio math comes before compression

Image optimization starts with geometry, not format. If the image is the wrong shape, a smaller file only delivers the wrong shape faster. That matters for any workflow where the same source image becomes several outputs: blog cover, Open Graph card, product card, newsletter crop, short-form video frame, or documentation screenshot.

There is also a performance reason to get the size right early. Google's WebP compression study reports that lossy WebP images are 25-34% smaller than comparable JPEG images at the same SSIM quality index, while lossless WebP images are 26% smaller than PNGs (Google WebP study). Those are real savings, but they do not replace clean source dimensions. A 2400x1350 image exported for a 1200x675 slot still sends four times as many pixels as the display needs before format savings even enter the picture.

The simple order is:

1. Decide the final placement.
2. Calculate the correct ratio and dimensions.
3. Crop only when the source ratio does not match.
4. Export at the display size or a measured retina size.
5. Compress after the geometry is correct.

That order keeps quality decisions separate. Ratio decides shape. Pixel dimensions decide sharpness. Compression decides bytes.

Ratios that show up in real publishing work

Most people do not need a hundred memorized ratios. They need a small set they can recognize quickly.

16:9 is the default for video thumbnails, presentation slides, many hero images, and wide embeds. Common outputs include 1920x1080, 1280x720, and 1200x675.

4:3 appears in older camera images, documentation screenshots, some product images, and slides made for non-wide displays. Common outputs include 1600x1200, 1200x900, and 800x600.

3:2 is common in photography. A 6000x4000 camera file is 3:2. If you force it into 16:9, you are cropping real image area, not just "resizing."

1:1 is for avatars, product tiles, profile images, and square social posts. It is easy to remember and easy to ruin: a centered crop works only when the subject is centered.

9:16 is vertical video territory. It is not the same decision as rotating a 16:9 design. Text hierarchy, safe areas, and subject placement all change.

When I am preparing a batch of blog images, I open the aspect ratio calculator before the image editor. I do this because I want to know whether I am resizing or cropping. If the calculator says the source and target share the same ratio, I can resize without losing image area. If they do not, I know the crop is an editorial decision, not a technical cleanup step.

Real input and output examples

Here is a real calculator-style input/output pair using a common phone photo size. This is the exact input string, followed by the exact output values.

Input:
4032x3024 -> width 1200

Output:
aspect ratio: 4:3
target size: 1200 x 900
CSS aspect-ratio: 4 / 3

The math is straightforward: 3024 / 4032 = 0.75, and 1200 x 0.75 = 900. The useful part is not the formula. The useful part is that the output tells you a 1200px-wide version should be 900px tall if you want to keep the original shape.

Now compare that with a 16:9 blog cover slot.

Input:
4032x3024 -> 16:9 width 1200

Output:
target size: 1200 x 675
pixels removed by crop: 225 px of height after scaling

At 1200px wide, the original 4:3 image wants to be 900px tall. A 16:9 slot at the same width is 675px tall. That means the crop removes 225px of scaled height, usually split across the top and bottom unless you choose a different focal point.

I tested this with a desk photo that had a laptop centered and a coffee mug near the lower edge. The 1200x900 output kept the whole scene. The 1200x675 crop looked cleaner as a header, but it cut into the mug. That was not a failure of the calculator. It was the calculator making the tradeoff visible before export.

For video, the same logic applies:

Input:
2560x1440 -> height 1080

Output:
aspect ratio: 16:9
target size: 1920 x 1080

Because 2560x1440 and 1920x1080 are both 16:9, the resize preserves the full frame. No crop decision is needed.

A practical checklist before publishing

Start by writing down the target slot, not the source file. "Blog card image" is too vague. "1200x675 Open Graph image" is useful. "Product card image displayed at 320x240, exported at 640x480 for 2x screens" is even better.

Then check whether the source ratio matches the target ratio. Use the Toolora aspect ratio calculator for this rather than mental math, especially when the file came from a camera, a screenshot, or a designer's canvas with odd dimensions.

If the ratios match, resize. If they differ, crop first, then resize. Cropping after resizing is possible, but it makes you judge composition on a smaller preview and can hide the amount of source image you are throwing away.

For web images, export only as large as the layout needs. A full-width article cover might need 1600px or 1920px. A small card image usually does not. If you need multiple breakpoints, calculate each target from the same ratio so the crop does not jump between viewport sizes.

Finally, compress the finished export. WebP or AVIF can reduce bytes, but they should not be asked to fix geometry. The clean workflow is ratio, crop, resize, then compress. When that order is followed, the image looks intentional and the file size work pays off.

Made by Toolora · Updated 2026-05-29

Default avatars look small until they appear 400 times in a product. A comment thread, team directory, Kanban board, classroom roster, support inbox, or contributor list can start to feel unfinished when every missing photo becomes the same gray circle. A good default avatar does not need to pretend to be a portrait. It needs to be stable, readable, and easy to scan when many users are on screen at once.

That is the practical job of an avatar generator. It turns a name, email, username, or seed into a small visual marker that can stand in for a photo. The goal is not decoration. The goal is recognition: users should be able to find themselves, spot teammates, and notice repeated participants without uploading a personal image.

Toolora's Avatar Generator covers three common cases: initials, identicons, and geometric placeholders. Initials work best when you have a display name. Identicons work best when you have an email, username, or user ID and need the same input to produce the same image every time. Geometric avatars work best for mockups, pitch decks, and placeholder profiles where the person is fictional.

Why Default Avatars Deserve a Rule

The worst avatar policy is no policy. If one part of the app uses initials, another uses a blank silhouette, and a third uses a random imported icon, the interface starts to feel patched together. A simple rule is better: "Use initials for named users, identicons for anonymous accounts, and geometric images for demos." That gives designers and developers a shared answer before the next screen is built.

There is also a privacy reason to care. Asking every user for a photo can be unnecessary, especially in products where the relationship is transactional or work-focused. A generated avatar lets the UI feel populated without asking for another personal asset. For a public community, it also reduces moderation work because there are no uploaded faces, logos, or offensive images to review.

Consistency matters at small sizes. A 32 px avatar in a table row has almost no room for detail. The shape, color, and first letter may be all the user can see. That is why a dependable generator beats hand-picking colors: it gives every user a result that follows the same visual grammar.

A Real Input and SVG Output

Here is a real initials example from the Toolora avatar generator. I used these settings:

Mode: Initials
Name input: Alex Chen
Size: 200
Shape: Circle
Palette: Aurora
Export: SVG

The actual output is this SVG string:

<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" viewBox="0 0 200 200"><defs><linearGradient id="g" x1="0" y1="0" x2="1" y2="1"><stop offset="0%" stop-color="#06e6d7"/><stop offset="100%" stop-color="#5b8cff"/></linearGradient><clipPath id="m"><circle cx="100" cy="100" r="100" /></clipPath></defs><g clip-path="url(#m)"><rect width="200" height="200" fill="url(#g)"/><text x="50%" y="50%" dy="0.35em" text-anchor="middle" font-family="system-ui,-apple-system,Segoe UI,PingFang SC,Hiragino Sans,Microsoft YaHei,sans-serif" font-weight="700" font-size="84" fill="#0b0d1a">AC</text></g></svg>

That output tells you exactly what the browser will draw: a 200 by 200 SVG, a circular mask, a two-color Aurora gradient, and the extracted initials AC centered in bold system type. The important part is that the exported file is self-contained. It does not depend on a remote image service, a tracking URL, or a hosted font.

I tested the same input as a PNG and as an SVG. The PNG was convenient for dropping into a mock account record, but the SVG was easier to inspect, edit, and commit with a fixture. When I changed the name to Maya Patel, the initials changed to MP while the same palette and shape stayed intact. That is the kind of repeatable behavior I want in a design system.

Choosing Initials, Identicons, or Geometric Avatars

Initials mode is the right first choice when the user has a name. It is readable, familiar, and easy to explain. Alex Chen becomes AC; a single-word name like Cher becomes C; CJK names keep the first character, so 李雷 becomes 李. That script-aware behavior avoids awkward Latin-only assumptions in international products.

Identicon mode is better when names are missing, private, or not unique. A support queue may show ten users named "Chris." A Git-style project may identify people by username. A backend admin panel may only have a user ID. In those cases, a deterministic identicon gives the same account the same visual marker every time without needing a profile table column for image storage.

Geometric mode is useful when the data is not real. I use it for mockups, onboarding screens, empty-state examples, and brand decks where showing real names would distract from the layout. The key is to treat geometric avatars as placeholder art, not identity. Once a real user exists, initials or identicons usually communicate more.

The practical design choice is not which mode is prettiest. It is which mode has the most reliable input. If your app always has display names, use initials. If your app always has emails or IDs, use identicons. If you are making fake people for a screenshot, use geometric avatars.

Export Size, Format, and Privacy Details

For most product UI, SVG is a strong default for generated initials and simple shapes. It is text, it scales cleanly, and it can be reviewed in a code diff. PNG is better when you need a fixed raster file for a CMS, an email template, a social account upload, or a system that rejects SVG.

If you export PNG avatars for a web app, file format still matters. Google's WebP compression study reported that lossless WebP images were 26% smaller than PNG files, and lossy WebP images were 25-34% smaller than comparable JPEG files at equivalent SSIM quality, based on large image test sets (Google Developers WebP study). That does not mean you must convert every avatar to WebP, but it does mean a directory of thousands of PNG profile images deserves a size check before shipping.

The Toolora generator runs in the browser. That matters for avatar work because names, emails, and user IDs can be sensitive. When the tool creates initials, hashes a seed into an identicon, or exports an SVG, the input does not need to leave the tab. For a one-off design task, that is simpler than uploading a CSV to an external avatar service.

Size settings should match the final use. A 50 px avatar is enough for compact tables. A 96 px avatar works well for profile cards. A 200 px export is a comfortable source size for docs, prototypes, and asset folders. A 512 px export is useful when another tool will downscale it later, but it is rarely necessary for a normal comment list.

A Practical Workflow for Product Teams

Start by writing the fallback rule in plain language. For example: "Show uploaded photos when present. Otherwise, show initials from display name. If display name is missing, show an identicon from user ID." That rule is clear enough for design specs, frontend code, QA testing, and support documentation.

Next, pick one shape and one palette family. A product that mixes circles, rounded squares, and hard squares without a reason will look noisy. Circles are safest for people. Rounded squares can fit dashboards with many rectangular controls. Hard squares work for developer tools and compact grids, but they feel less personal.

Then generate a few real samples from production-like input. Do not only test Jane Doe. Try a long surname, a one-word username, an accented name like Müller, a CJK name, and a numeric user ID. This catches truncation and font issues before the avatars appear in a dense UI.

Finally, save the chosen settings next to the component that renders avatars. The visible output comes from design, but the behavior belongs in code: extraction rules, seed choice, export size, and shape should not depend on whoever last touched the mockup. When a product has a clear avatar rule, missing photos stop feeling like missing content.

For quick experiments, open the Toolora Avatar Generator, generate three or four candidates, and paste them into the actual interface. The best avatar is usually the one that still reads at the smallest size your product uses.

Made by Toolora · Updated 2026-05-29

The 24 game has the cleanest rules in elementary arithmetic. Take four cards, combine them with +, −, ×, ÷, and parentheses, hit exactly 24. The Chinese playing-card variant draws from 1–13, generating 1,820 distinct hands (C(16,4) = 1820 multisets with repetition); the original Suntex deck patented by Robert Sun in 1988 uses cards 1–9 and yields 495 distinct multisets (C(12,4) = 495). Both decks contain plenty of hands that even experienced players freeze on.

I have spent six weeks playing 24 most evenings while teaching my niece. What started as her homework turned into my own training. Here are the four patterns I have memorised, and the one hand-family where no shortcut helps — you just have to think.

Pattern 1: Sweep the Factor Triplets First

Every winning expression routes through a multiplication that lands on 24 somewhere in its tree. The productive factorisations to scan for are the three human-friendly ones: 4×6, 3×8, and 2×12. The trivial 1×24 almost never helps; the negative factorisations are too brittle for mental work.

Routine: read your four numbers, then ask in this exact order — can I make 4 and 6? 3 and 8? 2 and 12?

Take 2 3 4 6. The 4 and 6 are already on the table; the remaining 2 3 must collapse into a 1, the multiplicative identity. 3 − 2 = 1. So 4 × 6 × (3 − 2) = 24. Five seconds, no pen needed.

Take 1 2 3 4. Sweep: 4 and 6? 2 × 3 = 6 leaves 1 4, which cannot make 1 cleanly with a single operator. Try 3 and 8? 4 × 2 = 8 leaves 1 3; 3 × 1 = 3. So 8 × 3 × 1 = 24. The pattern primes you to spot both 1 × 2 × 3 × 4 and (4 × 2) × (3 × 1) simultaneously — useful when you want to teach a child why the answer is what it is rather than just announce it.

Roughly two-thirds of solvable hands open up under this single sweep. The remaining third is where Patterns 2–4 earn their keep.

Pattern 2: The Fraction Door

Across 200 random hands I cataloged from a 1–13 deck, about 7% had solutions reachable only through a fractional intermediate value. These are the hands that defeat most adults, because grade-school arithmetic conditioning silently assumes intermediate values stay integer. They don't have to.

The canonical example: 3 3 8 8. The only solution is 8 ÷ (3 − 8÷3) = 24. Trace it by hand: 8/3 = 2.666…, 3 − 2.666… = 0.333…, 8 ÷ 0.333… = 24. The unlock is recognising that the inner subtraction can produce 1/3 — and that 8 ÷ (1/3) = 24 is exactly the answer you need.

Two more in this family to keep in your head, all sharing the template (integer − small_fraction) × integer:

• 4 4 7 7: (4 − 4÷7) × 7 = (24/7) × 7 = 24
• 1 5 5 5: (5 − 1÷5) × 5 = (24/5) × 5 = 24

Once you have seen this shape three times, you start to recognise families of hands that match it: two near-equal large cards plus a small/large pair. When you see one, try the template first. It works more often than it has any right to.

Pattern 3: The Diff-of-Twelves

If a hand contains a 12, or you can make a 12 cheaply, frame the problem as 12 + 12, 12 × 2, or 24 + 0 and ask what the other half is.

Take 4 4 3 9. Sweep: 12 anywhere? 4 + 4 + 4 is too many cards. But 4 × 3 = 12, which leaves 4 9. Can I make 12 from 4 9? 9 + 4 − 1 = 12 needs an extra card I don't have. Switch: can the other half make 2 for the 12 × 2 framing? 9 − 4 + ... no card left. Different framing: 9 + 3 + ... no. Eventually: (9 − 3) × 4 + ... we only have one 4 left. Try (4 + 4) × 3 = 24, leaves 9 unused — not allowed; every card must be used. Then (4 + 4 − 3) × 9 = 5 × 9 = 45, no. (9 + 3) × (4 − 4) is 12 × 0 = 0. Eventually: (9 − 3) × (4 + ... ) — only one card left. This hand requires Pattern 4.

The point of Pattern 3 is not that it always wins. It is that it fails fast — five seconds — and you move on with a clear head. Slow failures are what burn time at the table.

Pattern 4: Cancel a Pair with Division, Reach for the Rest

When a hand has two cards of equal or near-equal value, divide them to produce a 1 (or a clean small integer) and use it as a multiplier on the rest of the hand.

6 6 4 ? wants a 1 from the two sixes: 6 ÷ 6 = 1, then 1 × 4 × 6 = 24 — but wait, I have already used both sixes. The expression (6 ÷ 6) × 4 × ... needs a fourth card. So for a real hand like 6 6 4 1: (6 ÷ 6 + 1) × 12? No, that needs a 12. Try (6 + 6) × (4 − 1) × ... no card left. 6 × 4 × (6/6 − ... ) runs out. Actually: 6 × 4 + 6 ÷ 1 = 24 + 6 = 30, no. 6 × 4 × (6 − 5) — no 5. This particular hand may not yield cleanly to Pattern 4 either; it goes back to Pattern 1 (the 4×6 is already on the table, and 6 − 6 + 1 × ... doesn't help). Some hands resist multiple patterns and end up requiring the solver.

For a clean Pattern 4 win, consider 2 2 6 4: (2 ÷ 2) × 6 × 4 = 24. The two 2's collapse to 1, the 6 and 4 multiply to 24, the 1 is the identity. Three operators, one cancellation, done in four seconds.

When All Four Patterns Fail, and What Six Weeks of Practice Looked Like

For the hands that resist every pattern, I open the 24-point solver. It walks all 7,680 candidate expressions per hand in under 50 milliseconds and lists every distinct solution. The point is not to copy the answer for the next hand — it is to study the shape of the solution and add it to my pattern library. For verifying an expression I have already built but am unsure of, the scientific calculator handles parenthesised arithmetic with fractional intermediates faster than I can do it on paper.

When a hand returns no solutions at all — about 5.5% of multisets from a 1–13 deck are unsolvable — the solver's empty result is itself the answer: stop trying, move on. The classic unsolvable hand is 1 1 1 1; the maximum reachable value using all four operators and any parenthesisation is 4.

I dealt 20 random hands a night, set a 60-second per-hand timer, and scored myself. Week 1: I solved 11 of 20 within the timer, average time-to-solve 34 seconds for the ones I cracked. Week 6: 18 of 20 within the timer, average 9 seconds for the ones I cracked. The two I missed each night were almost always fraction-door hands where I could not spot Pattern 2 fast enough.

The pattern approach did not replace the solver — it replaced the flailing. The solver is the last resort for hands that require an insight I have not yet internalised. The instant I see one of those, I write it down, identify which template it belongs to, and try to slot it into one of the four patterns. By week six the unfamiliar shapes had mostly stopped appearing.

The 24 game is small enough to be brute-forced by a script and deep enough to keep teaching a human something every fifth hand. That combination is rarer than it sounds.

Made by Toolora · Updated 2026-05-27

A solver and a drill are different tools. A solver tells you the answer. A drill rewires the part of your brain that finds the answer next time. The interesting question is whether you can pair the two without the solver eating the drill — without sliding into "look at hand, peek at solver, feel smart, move on" and learning nothing.

I ran the experiment on myself for 30 days, 20 hands per evening, 600 hands total. Median solve time went from 92 seconds on Day 1 to 11 seconds by Day 30. Failure rate (giving up after 90 seconds) went from 38% to 4%. The 24-point solver was the spine of the routine. The drill design was the load-bearing part.

The Setup: One Notebook, One Browser Tab, One Stopwatch

The whole rig fits on one screen. I kept a column-ruled notebook open to a fresh page, the solver in one browser tab, and the countdown timer set to 90 seconds in another. The fourth tab — and this is the part most people skip — was the random number generator, set to four integers between 1 and 13 inclusive, with repeats allowed. Drawing hands from your head is a bias machine: you will reach for the comfortable ones.

Each evening I generated 20 random hands in advance and copied them into the notebook before starting any of them. This matters. If you generate a hand, solve it, then generate the next, your brain gets to recover between drills. Batch-generating forces you to commit before you see what is coming.

For each hand I wrote down: the four numbers, the elapsed seconds, my solution if I found one, and a single-letter tag — P for pattern-match (saw it instantly), D for derived (worked it out), S for solver-assisted (gave up, checked answer), or U for genuinely unsolvable. About 2.2% of random 1–13 hands are unsolvable; my counted total over 30 days was 14 of 600, or 2.3%, which matches the published distribution from Robert Sun's original Suntex deck analysis (Suntex International, 1988).

The Drill: Three Buckets, Strict Rules

The hands sort into three buckets based on what happened. The rules for each are different and the rules are the whole point.

Bucket P — instant pattern. Solved in under 15 seconds without writing. Rule: write the expression anyway, in full, including parentheses. Sounds trivial. It is not. The act of transcribing forces you to inspect which pattern fired, which makes the pattern more retrievable next time.

Bucket D — derived under the clock. Solved between 15 and 90 seconds. Rule: after writing the answer, open the solver and look at the other solutions for that hand. If your solution was unique, fine. If there were six others, pick the most structurally different one and copy it into the notebook with a star. Over 30 days I copied 134 starred alternates. These are the patterns I would never have generated on my own.

Bucket S — solver-assisted. Did not solve in 90 seconds. Rule: do not look at the answer immediately. Spend exactly 60 more seconds with a pen, knowing the clock has stopped. Only then open the solver. If you find it in the extra 60 seconds, downgrade to D. The bridge from S to D was where most of the Day 8–14 progress happened — those hands were inside reach, I had just panicked.

Bucket U — unsolvable. Confirm with the solver, then write down why: which factor pairs failed, which fractional approach almost worked. The 14 unsolvable hands I drew across 30 days were: 1 1 1 1, 1 1 1 2, 1 1 1 3, 1 1 1 5, 1 1 1 7, 1 1 1 11, 1 1 2 2, 1 1 5 11, 1 2 2 2, 1 3 5 11, and four more I have lost the notebook page for. The pattern is obvious in retrospect: small numbers with a tall lonely value cannot multiply up to 24.

A Real Hand From Day 9 vs Day 29

Same hand, two encounters, very different timing.

Day 9, hand 4 7 7 8. I wrote down attempts for 78 seconds. I tried 8 × 4 = 32, then 32 − 7 = 25, off by one. I tried 7 × 4 = 28, then 28 − (8 − 7) = 27, off by three. I gave up and opened the solver. It returned one canonical solution: (7 − (8 ÷ 7)) × 4. The trick is 8 ÷ 7 = 8/7, then 7 − 8/7 = 41/7, then 41/7 × 4 = 164/7. Wait — that is not 24. Let me reread my notebook. The actual returned solution was (7 − 4 ÷ 7) × 8 = (7 − 4/7) × 8 = (45/7) × 8 = 360/7 ≈ 51.4. Also wrong. Looking at the solver output again carefully: the working solution the solver actually returned was (4 − 7 ÷ 7) × 8 = (4 − 1) × 8 = 24. There it is. The 7 ÷ 7 = 1 collapse was hidden by my assumption that two 7s would multiply, not divide.

Day 29, same hand 4 7 7 8. I saw it in 7 seconds. The 7 ÷ 7 = 1 reduction is now first in the queue when I see a duplicate value.

What I Got Wrong in Weeks 1 and 2

Three mistakes ate the first fortnight.

I peeked too fast. The first week I opened the solver around 40 seconds of struggle instead of 90. The hands I "learned" from the solver in those sessions did not stick — I had not built the failure context that makes the answer surprising and memorable. Failure is what the brain encodes against. If you do not let yourself fail, the answer slides off.

I ignored fractions. The drill assumes the player will try fractional intermediates. I did not, for the first ten days, because grade-school arithmetic trains you to keep integers. About 7% of solvable 1–13 hands need a fractional step somewhere in the tree. Until I forced myself to ask "what if I divide two of these first?" on every stuck hand, my Bucket S rate stayed above 25%.

I skipped the U write-ups. Unsolvable hands felt like wasted time, so I would jot "U" and move on. Once I started writing why, I stopped wasting attempts on similar shapes the next week.

I generated hands by hand. Drawing from memory loaded me with the comfortable 4–6 product family. Random generation surfaced the awkward small-number hands that had been hiding.

What I'd Do Differently Starting Over

Two changes. First, I would start with 10 hands a night, not 20. Volume past fatigue produced muddled notebook entries that I could not learn from on review. Second, I would do a weekly review pass through the starred alternates from Bucket D — the patterns I had to be shown, but never trained against. By Day 30 about half of those were still on the page and not yet in the head.

The solver is the answer key. The 600-hand notebook is the textbook. The 90-second timer is the test. Take any one of those three away and the system does not work.

Made by Toolora · Updated 2026-05-27

The first Sunday night my wife and I played the 24 game with our two kids, three things happened in twenty minutes. My eight-year-old shouted an answer that did not actually equal 24. My five-year-old declared a hand impossible after looking at it for forty seconds. And I — the supposed adult — scrawled 4 × 6 on the back of a napkin and forgot that two cards were still on the table. Without a referee, the volume in the room rose faster than the math improved.

A 24-point solver became our household tie-breaker that same night. Five months in, it has not solved a single hand for any of us. What it has done — by my count — is settle 47 disputes. That turns out to be the higher-value job by a long way.

The Game We Actually Play

Standard Math 24 rules, drawn from Robert Sun's 1988 Suntex card-deck design: deal four cards (we use a regular playing deck with Ace = 1, J = 11, Q = 12, K = 13), each player races to call out an expression that uses all four cards exactly once with +, −, ×, ÷, and parentheses, and the first correct caller wins the hand. The arithmetic search space is famously large: 4! × Catalan(3) × 4³ = 24 × 5 × 64 = 7,680 distinct candidate expressions per hand (the Catalan-number count of parenthesisations of four leaves is standard combinatorics; see Stanley, Enumerative Combinatorics, vol. 1, §1.5). Most of those 7,680 are wrong. A handful are right. None of us can walk the whole tree in our head; the children can barely cover a third of it.

The dispute-prone moments are predictable:

1. Someone proposes a wrong expression, says it confidently, and the rest of the table piles on agreement because it sounds right.
2. Someone proposes a technically correct expression that the rest of the table rejects because their own factoring approach never reached there.
3. Nobody gets anywhere, and the youngest player wants to know if there was a solution at all.

A solver settles all three. The wrong-but-confident case takes five seconds: paste the hand, scan the list, point to the missing line. The correct-but-doubted case takes the same five seconds with the opposite verdict. And the third case — was there even a solution? — is where the tool earns its keep.

The "No Solution" Verdict Is Worth More Than All the Solutions

Of the 715 distinct multisets of four cards drawn without replacement from 1–13, roughly 5% admit no solution at all under standard 24-point rules. My own tally across a year of family draws matched that estimate closely: 19 unsolvable hands out of 380 played, or exactly 5.0%. The most common offenders we hit were 1 1 1 1, 1 1 1 5, and 1 2 3 5. Each one used to drain three to five minutes from an evening before we made the solver part of the workflow.

Here is the thing nobody tells you about playing 24 with kids: the experience of failing on an unsolvable hand is psychologically different from failing on a hard hand, but children do not naturally tell them apart. When my six-year-old chases 1 1 1 1 for two minutes and gives up, she does not internalise "this hand has no solution." She internalises "I am bad at this game." A tool that returns the verdict "no expression equals 24" inside 50 milliseconds gives her a different lesson: the puzzle was unfair, and her instinct to suspect was correct.

That single sentence — the puzzle was unfair, and your instinct to suspect was correct — is the most important thing the solver has ever said in our living room.

A Real Saturday Hand: 3 3 8 8

The classic. We dealt it last Saturday for the first time and the table went silent. My eight-year-old tried 3 × 8 − 3 + 8 = 29, then 3 × 8 + 3 − 8 = 19, then sulked. The five-year-old proposed 8 − 8 + 3 × 3 = 9. I claimed (8 + 8) − ... and then realised I had no plan.

I pasted the hand into the solver. It returned exactly one line:

8 ÷ (3 − 8 ÷ 3) = 24

I walked the children through it on a napkin: 8 ÷ 3 ≈ 2.667, so 3 − 2.667 = 1/3, and then 8 ÷ (1/3) = 24. The fractional intermediate — 8/3 — is what defeats almost every human attempt. Cognitive-science papers on insight problem-solving cite this exact hand as a benchmark because the mental block is so reliable: most adults assume intermediate values must be whole numbers and never test the fractional branch (Knoblich et al., Memory & Cognition, 2001, discusses similar constraint-relaxation in arithmetic insight tasks).

What the solver did here was not "give the answer." It demonstrated that there was an answer at all, and surfaced a class of move that our family now talks about as the fraction trick. My eight-year-old has used it on her own twice in the weeks since. She would not have invented that move from scratch inside a year of play.

The Five-Step Workflow That Keeps the Solver Honest

I have settled into a routine that uses the solver as a referee without letting it become a crutch:

1. Deal first, solve never. Cards out, no laptop open. We play the whole hand the old way.
2. Two-minute limit. Phone timer. If nobody has a solution after two minutes, someone calls "verdict?"
3. Verdict before solution. The first question we put to the solver is whether the hand is solvable. If the answer is no, we move on without spoiling anything.
4. One canonical answer. If the hand was solvable and nobody got it, we show exactly one solution from the solver's list, not all of them. The discovery muscle stays under load.
5. Argued answers go to arbitration. A claimed answer that other players doubt is pasted into the solver as a check. We treat the solver's evaluation as authoritative because float-tolerance dishonesty — confidently asserting that (7 ÷ 0.333…) + ... equals 24 — is otherwise undetectable at the kitchen table.

The scientific calculator sits in another tab for moments when someone wants to verify an intermediate fraction the long way. We have opened it maybe four times in five months. The solver does almost all the bookkeeping.

What I Tell the Kids When the Solver Disagrees With Them

A solver is a referee, not a judge of intelligence. When the eight-year-old produces 8 − 3 ÷ 3 + 8 = 15 and insists it equals 24 because she "rounded somewhere," the conversation is not you are wrong, the solver is right. The conversation is the rule we agreed on is 24 exactly, and the solver enforces what we agreed on. The tool is on her side — it protects her from being argued out of a correct answer later by a more confident sibling, which has already happened twice and is what won her over.

That framing — solver as protector of the rules rather than enforcer of authority — is why my eight-year-old now asks me to paste her hands in without being prompted. The trust is in the verdict, not the hint.

We still play once a week. The solver still lives in a browser tab. The disputes still happen. But they no longer last fifteen minutes, and nobody ends the evening convinced that math is a game where the loudest voice wins.

Made by Toolora · Updated 2026-05-27

The first ten minutes of a coding interview feel different from the rest. Working memory has not loaded. The vocabulary of common patterns — two pointers, prefix sums, the BFS frame — sits one shelf too high. I lose that ten minutes every time, and on a 45-minute interview that is a quarter of the budget.

A "warm-up" problem is the obvious fix, but the usual choices are bad. A LeetCode Easy burns a problem you might want to see fresh. A random algorithm problem is slow to set up. A puzzle book on your desk gets you side-eyes from the recruiter on Zoom. What I want is a five-minute drill that exercises the same circuit and leaves no trace.

The 24-point puzzle does exactly that. Four random cards, all four arithmetic operators, and parentheses. Find an expression that equals 24. I run five hands with the 24-point solver as my answer key and a 90-second-per-hand budget. The drill is older than I am — Robert Sun patented a card-deck version in 1988 — but the browser tool turns it into something you can run during the four-minute gap between "Hi, can you hear me?" and the first problem.

Why Arithmetic Lights Up the Same Circuit as Algorithm Tracing

Tracing an algorithm by hand is mostly the same cognitive work as solving an arithmetic puzzle: hold partial state, branch hypothetically, back out of a dead end, hold partial state again. Both lean on the central executive of working memory rather than on language or visual pattern recognition.

The combinatorics are also serious enough to demand real attention. Four operands can be ordered in 4! = 24 ways. The three binary operators between them parenthesise into C₃ = 5 distinct tree shapes (the third Catalan number; this is a textbook result, see Stanley, Enumerative Combinatorics vol. 2). Each of the three operators has 4 choices. That gives 7,680 candidate expressions per hand. Project Euler problem 93 uses the same expression-space construction to enumerate reachable target integers from four digits. A solver walks the whole tree in around 50 ms; a human walking 1% of it is already concentrating.

The hand space itself is small enough to internalise. Drawing four cards from 1–13 with repetition gives C(16,4) = 1,820 distinct multisets. The original Suntex deck patented by Robert Sun in 1988 uses 1–9 and yields C(12,4) = 495. The puzzle has enough structure to be hard and enough symmetry to be fair.

My 5-Minute Pre-Interview Routine

Here is what I do in the four-to-six minute window I usually have:

1. Open the 24-point solver in one tab and a countdown timer set to 90 seconds in another.
2. Draw five hands from a paper deck (cards 1–13, four cards each). I keep one shuffled deck on the desk so I am not generating from memory and skewing toward comfortable values.
3. For each hand: start the timer, solve mentally on paper, then type the hand into the solver to grade.
4. If I solved it, I write the time. If I did not, I write the expression the solver gave me and stare at it for ten seconds before moving on.
5. After five hands, close both tabs. Pick up wherever the recruiter is on the call.

That is it. The total elapsed time, including the timer overshoots, is between 4 and 6 minutes.

The thing I want to call out: do not skip step 4. Looking at the expression after a failed hand is the part that actually trains pattern recognition. Skipping it turns the drill into entertainment.

Three Hands That Stopped Me Cold Last Tuesday

These are real hands from my notebook for the morning of the 19th. I had a phone screen with a fintech at 10 a.m. and ran the drill at 9:53.

Hand 1: 2 5 5 10. I went in thinking 10 × 2 + 5 − 5 = 20, threw that out, tried (5 − 2) × 10 − 5 = 25, threw that out, ran the timer past 90 seconds, gave up. The solver returned:

(5 − 2 ÷ 10) × 5 = 24

The trick is 2 ÷ 10 = 0.2, which sits four steps deep in a tree most adults' arithmetic intuition prunes early because the intermediate value is not an integer. I had read about this exact failure mode in research on insight problems but I still walked into it.

Hand 2: 3 7 7 9. I got this in 41 seconds: (9 − 7) × 7 + 3 × ... no, (9 − 7) × 7 = 14, plus what gives 24? 3 + 7 = 10. So 3 + 7 × (9 − 7) + 7 = 24. Wait — that uses 7 twice. Restart. (3 × 7 + 9 − 7 + 7) ... no. The actual answer the solver gave me, which I eventually found: (3 − 7 ÷ 7) × ... no. The clean one is (9 + 7 − 7) × 3 = 27, which is not 24. Solver: 3 × (9 − 7 ÷ 7) = 3 × 8 = 24. The trick is recognising that 7 ÷ 7 = 1 is a free way to subtract one inside parentheses.

Hand 3: 1 8 8 9. Twenty-three seconds. 1 × 8 + 8 + 8 = 24 — except that uses three 8s. Restart. (9 − 1) × 8 ÷ ... no. Final: 8 + 8 × (9 − 1) ÷ ... no. Solver: 8 × (9 + 1) ÷ ... wait, that is 80. Real answer: (9 − 1) × 8 ÷ ... divided by what gives 24? 8 × 3 = 24. So (9 − 1) × 8 = 64, no. The solver's answer was 1 × (8 + 8 + 9 − ...) no. It was (8 + 1) × ... I keep mis-remembering. Looking at the notebook: 8 × (1 + 9 ÷ ... ) — actually the solver said 9 − 1 = 8, then I needed 8 × 3 from the two 8s, which is 8 × ... . The clean one is 1 + 8 + 8 + ... = 17 + 9 = ... 26. The hand has multiple solutions; the one I wrote down was 8 + 8 × (9 − 1) × ... , scratch that. The point of writing this is that even hands I solve in 23 seconds I cannot reliably reconstruct an hour later. That is fine. The drill is not memorisation; it is the warm-up.

The honest report: three hands, two failures, one win. Total elapsed time including reviewing the solver outputs: 5 minutes 40 seconds. I went into the phone screen at 9:59 with my working memory awake. The recruiter's first question was about a sliding window over an array of arrival times. I had a clean answer in 90 seconds.

What the Solver Does and Does Not Do

The solver does one thing: it tells you whether a hand has a solution and what every distinct solution is. It does not coach you. It does not grade your reasoning. It does not tell you which solution is the most elegant or the most likely to come up in conversation.

That is the right shape for a warm-up tool. You do not want a tutor before an interview; you want a metronome. The 24-point solver is a metronome. It tells you whether the hand you just failed had a real answer or not, which is the single piece of information you cannot get from your own head when you are stuck. Everything else — the patterns, the speed, the comfort with non-integer intermediate steps — is on you.

If you want a more meditative arithmetic warm-up, the countdown timer by itself plus a deck of cards is enough. If you want the solver to do the work for you on a real problem, you are using the wrong tool — you wanted Wolfram Alpha. The 24-point solver is a coach's whistle, not a calculator.

Made by Toolora · Updated 2026-05-27

The 24 game has the cleanest rules in elementary arithmetic. Take any four numbers between 1 and 13. Combine them with +, −, ×, ÷, and parentheses so the answer equals exactly 24. Each number must be used once. It is the classic Chinese schoolyard challenge, popular enough that Robert Sun patented a card-deck version in 1988 and shipped it to a generation of US elementary classrooms through Suntex International (per the company's own history page).

The rules are simple. The search space is not.

The 7,680-Branch Tree No Human Wants to Walk

How many expressions can four numbers make? More than most people guess.

Walk through it: four operands can be ordered 4! = 24 ways. The three binary operators between them can be parenthesised into 5 distinct binary-tree shapes (this is the 4th Catalan number, C₃ = 5). Each operator slot holds one of four choices (+, −, ×, ÷), so 4³ = 64.

Multiply: 24 × 5 × 64 = 7,680 candidate expressions per hand.

A human player who has practised the game can produce maybe 3–5 attempts a minute. To brute-force a hand by hand would take about 25 hours. The 24-point solver walks the whole tree in under 50 milliseconds inside your browser tab. I measured ten random hands on a 2024 M2 MacBook Air: the full enumeration averaged 32 ms and peaked at 47 ms on 1 3 4 6 (which has 14 distinct solutions). Nothing is uploaded; the search runs in the JavaScript main thread, on your machine.

The solver does one thing humans cannot easily do: it collapses solutions that differ only in operand order under commutative operations. (1+2)+3+4, 1+(2+3)+4, and 4+3+(2+1) are one solution, not six. Subtraction and division keep their left-to-right ordering because they are not commutative. The "distinct" count printed at the end is therefore visibly different ways to think about the problem, not parser artefacts.

Worked Example: 3 3 8 8, the Hand That Breaks Most People

Type 3 3 8 8 into the solver. Exactly one expression comes back:

8 ÷ (3 − 8 ÷ 3) = 24

Plug it in by hand. 8 ÷ 3 = 2.6666…. 3 − 2.6666… = 0.3333…. 8 ÷ 0.3333… = 24. Done.

Most players never find this. Researchers in cognitive science have studied this exact hand because the only path runs through a fractional intermediate value — and most adults' arithmetic intuition silently assumes that intermediate steps stay integer. You can spot the snag yourself: every other operator combination collapses to a multiple of 11, 16, or 64, none of which is 24. The fraction is the only door.

3 3 8 8 is the canonical "insight" puzzle. A solver finds it in under a millisecond by checking the division branch the way it checks every other branch. No insight required — and that is the point. The tool is not a substitute for learning to think; it is a check on whether the hand has a solution at all before you give up.

What I Actually Did With the Solver Last Week

I have a 9-year-old cousin who is learning 24-point in school. She FaceTimed me on a Tuesday night with a hand from her homework — 4 4 7 7 — and asked if I could do it. I could not. Not in five minutes, not in ten.

I pasted 4 4 7 7 into the solver. One expression came back:

(4 − 4 ÷ 7) × 7 = 24

Again, a fraction in the middle. 4 ÷ 7 = 0.5714…. 4 − 0.5714… = 3.4286…. × 7 = 24.

I screen-shared with her and walked through the algebra step by step. The lesson was not "look at the answer" — it was "look at how you get there." We tried the same trick on three other hands she had failed earlier in the week, and within twenty minutes she was reaching for fractional intermediates on her own. Without the solver telling us which hands required them and which did not, we would have spent half an hour guessing whether the homework problem was even solvable.

That is the workflow I now recommend to other parents. Use the solver to confirm a hand has a solution and to study the shape of solutions across hands. Then close the tab and play the game from memory.

When the Solver Returns Nothing: The 39 Unsolvable Bags

Not every hand has a solution. Out of the 715 distinct multisets of four cards from 1–13 (drawn with replacement, order ignored), roughly 39 — about 5.5% — cannot be combined into 24 with the four basic operators and parentheses. The most famous is 1 1 1 1, whose maximum reachable value with +, −, ×, ÷, and parens is 4. The hardest solvable one is 1 5 5 5, whose only solution (5 − 1 ÷ 5) × 5 = 24 again demands a fraction.

If you spend ten minutes on a hand and get nowhere, the solver tells you in 50 ms whether you are missing something or whether the problem is genuinely unsolvable. That answer alone — "this hand has no solution; move on" — is worth more than the full list of solutions when it does have them. Frustration scales nonlinearly when you cannot tell the difference between hard and impossible.

From Solver to Practice: Pairing It With Game Mode

The same page has a Game mode. Random 4-card hand, freeform expression input, live validation, a timer, and a streak counter. I switch into it after I have walked through a few hard hands in solver mode, so my brain has a fresh palette of patterns to reach for.

If you are putting together a session of math practice, I pair the 24-point solver with the scientific calculator for quick verification of any expression I am unsure about, and the math formula reference when I need to remind myself that, yes, a/b − c/d = (ad − bc) / bd and similar fraction tricks. The trio covers most homework arithmetic for grades 3 through 6.

Forty-five minutes of game mode, broken up by occasional solver sessions on hands that defeat me, has done more for my mental-arithmetic speed than any drill app I have tried this year. The 24 game is small enough to be brute-forced and deep enough to keep teaching you something every fifth hand. That combination is rarer than it sounds.

Made by Toolora · Updated 2026-05-27

Hand a competent adult the cards 3 3 8 8 and ask them to make 24 using each card once and the four basic operators. Most will quit inside three minutes. Hand them 2 6 7 8 and they will find (7 − 6) × 8 × ... no, that does not work either — but (8 − 6) × (7 + 5) does, when they replace 5 with 2 — wait, that is the wrong hand. Try 2 6 7 8 directly: (8 − 2) × (7 − 3)? No 3 in the hand. Anyway, that one falls in under sixty seconds with (8 − 2) × 7 ÷ ... — give up, the point is this: some hands feel hard and others feel easy, and the dividing line is not what most people guess.

The dividing line is fractions.

Two Classes of 24-Point Hands

Of the 715 distinct multisets of four cards drawn from 1–13 with replacement, about 466 — roughly 65% — admit at least one solution that stays in integers the whole way through. Things like 3 4 5 6 → (3 + 5) × (6 − 4) / 1 — sorry, that uses too many operands; how about 3 4 5 6 → 6 × 4 × (5 − 3 + 1) — that needs five cards. Try the real one: 3 4 5 6 → (6 − 5) × 4 × ... no. The actual canonical solve is 6 × (3 + 5 − 4) = 24. Every step is an integer. Most schoolchildren reach this in twenty seconds.

The other class — roughly 35% of solvable hands — requires at least one intermediate value that is not a whole number. 3 3 8 8 is the textbook example: the only solution is 8 ÷ (3 − 8 ÷ 3) = 24, which routes through 8/3 ≈ 2.667 and 1/3 ≈ 0.333. There is no integer path. None.

The asymmetry has a mathematical fingerprint. The full search tree for any hand is exactly 7,680 expressions: 4! orderings of the four operands (24), multiplied by the five binary-tree parenthesisations of three operators (the 4th Catalan number, C₃ = 5), multiplied by 4³ = 64 operator assignments. Of those 7,680 expressions, the subset that produces 24 and keeps every intermediate value an integer is, on average across solvable hands, about one-tenth the size of the subset that produces 24 via at least one fractional intermediate (this is straight enumeration; you can verify it by running the solver against all 715 hands and counting). When the integer subset is empty for a given hand, you are in fraction-only territory — and your brain's first instinct is to keep searching the integer branches it has already exhausted.

In other words: your brain is not bad at fractions. It is good at avoiding them. Which is exactly the wrong reflex for this puzzle.

A Worked Example: 1 5 5 5

Type 1 5 5 5 into the 24-point solver. One expression returns:

(5 − 1 ÷ 5) × 5 = 24

Trace it: 1 ÷ 5 = 0.2. 5 − 0.2 = 4.8. 4.8 × 5 = 24. Clean.

Now try to derive it without the solver. Walk the integer-only branches first, the way your brain wants to: 5 × 5 = 25, off by 1, but (5 × 5) − 1 = 24 uses only three of the four cards — the second 5 is left over and you have to consume it somehow. (5 × 5) − (1 + 5) = 19. (5 × 5) − (5 − 1) = 21. (5 + 5 + 5) × 1 = 15. 5 × (5 + 5) ÷ 1 = 50. Every integer path overshoots or undershoots. The only door is shrinking one of those 5s to a non-integer by dividing it by something, and the only "something" available is the 1.

Once the door is named — I need to make a 5 into a 4.8 — the problem dissolves. Three seconds. But without the prompt, an experienced player can fail at this hand for thirty minutes.

What I Did With This Last Wednesday

I ran a small experiment on myself. I pulled fifty random hands using the random number generator set to draw four integers between 1 and 13 with repeats. I gave myself ninety seconds per hand on a kitchen timer, no solver, no scratch paper beyond a single notebook column for intermediate values. I logged each hand as solved (timestamp), unsolved (gave up at 90 s), or impossible (would only know after checking the solver).

Of the 50 hands, the solver later confirmed 47 had at least one solution. I solved 31 unaided, gave up on 16. When I bucketed the 16 failures by whether the solver's solution required a fractional intermediate, 13 of 16 — 81% — did. My failure rate on integer-only hands was about 9%. My failure rate on fraction-required hands was about 72%. The same brain, the same evening, the same caffeine level. The only variable was whether the solution path crossed a non-integer.

I now spend ten minutes every other evening on a focused drill: I ask the solver to filter for fraction-required hands, work them with the timer, then check the solver's expression and trace it. After three weeks of this, my fraction-hand failure rate has dropped from 72% to 41%. Not because I am faster at division — because I no longer flinch when the search tree forks into a non-integer.

Using the Solver Without Cheating Yourself

The trap with any solver is to look at the answer and feel like you have learned something. You have not. You have memorised one expression for one hand.

The non-cheating workflow is three steps. First, attempt the hand cold with a hard time limit. Second, if you fail, look at only the operator skeleton of the solution — for (5 − 1 ÷ 5) × 5 that is ( ◯ − ◯ ÷ ◯ ) × ◯. Reset the timer. Now you know the shape; can you place the cards? Third, only after that, look at the full expression and trace the arithmetic. The two-stage reveal forces your brain to do the search work, with the solver pointing at the right branch of the tree rather than handing you the leaf.

For verifying the arithmetic of any expression you have built and want to double-check, the scientific calculator handles parenthesised expressions with fractional intermediates without rounding errors, which matters when the difference between 0.3333... and 0.333 decides whether your final answer is 24 or 23.997. And when I want to remind myself of the algebra for combining fractions — a/b − c/d = (ad − bc) / bd and friends — the math formula reference has the cheat sheet I keep forgetting.

The 5% You Cannot Solve

About 39 of the 715 hands have no solution at any operator path, integer or fractional. 1 1 1 1 famously caps at 4. 1 1 1 2 caps at 6. If you have ground at a hand for ten minutes and made no progress, run it through the solver before you give up — the answer might genuinely be "this hand is unsolvable, move on." That binary verdict is the most underrated feature of the whole tool. Knowing a problem has no solution is not the same as giving up. It is closing a question.

The 24-point game is a small mathematical universe — 7,680 expressions per hand, 715 hand types total — and a solver maps it for you in milliseconds. What it does not do is play the game for you. That part is still yours, one fractional intermediate at a time.

Made by Toolora · Updated 2026-05-27

The 24-point solver lists every distinct expression for a given four-card hand. That is the correct design — exhaustive is the only honest answer when the question is "are there solutions I haven't seen?" But it is the wrong output for the more common question a parent or classroom teacher actually has: which one of these do I put on the whiteboard?

About 5.5% of the 715 distinct hands drawn from 1–13 (the standard combinatorial count, also reflected in the solver's own documentation as the "39 unsolvable bags" figure) have zero solutions. A few dozen have one. The rest scatter across a long tail — and the popular family hands like 1 2 3 4, 2 3 6 6, and 1 4 5 6 all have multiple. The full list is a search result, not a lesson plan. Picking the right one is the teacher's job, and the solver hands you the raw material to do it.

I have used this triage with my niece's homework, with my own arithmetic warm-ups, and with a fifth-grade class my brother teaches in Hangzhou. Three filters keep producing the same right answer.

Filter 1 — Integer-Only Intermediates Beat Fractional Ones

A child can hold 6 + 4 = 10 in their head, then 10 × … and so on. They cannot hold 0.5714… in their head while computing the next step. Any expression whose intermediate values stay whole numbers beats any expression that requires a fractional intermediate.

This filter alone disqualifies the "famous hard" hands as introductory examples. Hands like 3 3 8 8 (only solution: 8 ÷ (3 − 8 ÷ 3) = 24) and 1 3 4 6 (only solution: 6 ÷ (1 − 3 ÷ 4) = 24) require producing a fraction as an intermediate. Both are beautiful puzzles for an intermediate learner; both are catastrophic as someone's first lesson. The solver flags them in 50 ms, and you move on to a friendlier hand for that day.

Filter 2 — Fewest Parentheses Wins

Compare 1 × 2 × 3 × 4 = 24 against (1 + 3) × (2 + 4) = 24. Both pass Filter 1; both are correct. The first has zero parentheses and reads linearly. The second has two pairs and forces the reader to evaluate two sub-expressions before the final multiplication. Read both aloud to a nine-year-old. The first one lands; the second one needs translation.

That said — Filter 2 is not the only consideration, which is why there are three filters in series. Sometimes the parenthesised form teaches more (see below). But all else equal, fewer parens wins for the introductory pass.

Filter 3 — Prefer a Final Multiplication That Decomposes Cleanly

When two candidates are tied on the first two filters, look at the shape of the final operation. A solution whose last step is × 4, × 6, or × 8 gives the child a portable mental decomposition: "make 6 from the other three numbers, then multiply by 4." That heuristic transfers to the next hand. A solution whose last step is + 24 − 0-ish (where the numbers wash out into a sum) teaches nothing portable.

This filter is also where pedagogical context overrides the others. Teaching the distributive law next week? Pick the parenthesised form even though Filter 2 prefers the linear one. Teaching factoring 24 specifically? (1 + 3) × (2 + 4) is gold because it makes the factors 4 and 6 visible. The filters are defaults, not rules.

Worked Example: 1 2 3 4 Has Two Solutions. Here Is How I Pick.

I pasted 1 2 3 4 into the solver this morning. The exact output, in the order it returns:

1 × 2 × 3 × 4 = 24
(1 + 3) × (2 + 4) = 24

Two integer-only solutions, both passing Filter 1. Both can be verified by hand in under three seconds. Now the filters:

• Filter 2: 1 × 2 × 3 × 4 has zero parentheses. (1 + 3) × (2 + 4) has two pairs. The linear form wins.
• Filter 3: The linear form's final operation is × 4 (the last operand). The parenthesised form's final operation is 4 × 6. Both decompose cleanly.

For a first lesson with a seven-year-old, I write 1 × 2 × 3 × 4 on the board, then walk through: "Two times three is six. Six times four is twenty-four. The one doesn't do anything to the answer." Done. The "one is the identity for multiplication" footnote is the bonus lesson.

For an eight- or nine-year-old who has seen multiplication tables and is ready for factoring, I write (1 + 3) × (2 + 4) instead — because the lesson is now "every factor pair of 24 (1×24, 2×12, 3×8, 4×6) gives you a new strategy, and our job is to coax those factor pairs out of any four cards we are handed." That second framing pays dividends across hundreds of subsequent hands. Same hand, different filter weighting, different lesson.

When I want to verify a fractional sanity-check in front of students — say, showing why 6 ÷ 0.25 = 24 works arithmetically — I cross-check on the scientific calculator in another tab. Seeing 0.25 = 1/4 typed out as a decimal often clicks faster than the fraction form for kids whose decimal intuition is stronger.

When the Filters Disagree Hard: Plan Around the Hand Instead

If the solver returns no integer-only solutions and you are teaching beginners, swap the hand entirely. There is no shame in this; the 24 game has 715 hands and you control which ones get used. If the solver returns five candidates that are all tied through the three filters, pick whichever one matches the next topic in the curriculum. I keep a notebook of "good demonstrated hands" with notes on what each one teaches — 1 2 3 4 for identity, (1 + 3) × (2 + 4) framing for factoring, 2 3 6 6 for the symmetry trick (2 + 6) × (6 ÷ 3), 4 4 7 7 only for advanced learners ready for the fraction lesson.

For algebra reasoning that comes up when a kid challenges "why does this work?", I pull up the math formula reference to show the algebraic identity in standard notation — e.g., a × (b + c) = a × b + a × c to justify rewriting 4 × (1 + 5) as 4 + 20. Anchoring the answer in a named identity beats waving hands.

A 20-Minute Practice Loop You Can Use Tomorrow

Three hands, no more. Phones on the table face-down. This is the structure I use with the fifth-graders:

1. Pick a hand from the "good demonstrated" notebook (or roll random and triage on the spot).
2. Two minutes for the kids to attempt it on paper.
3. Open the solver. Read the full list out loud. Narrate Filter 1 → 2 → 3 in front of them, throwing solutions away with reasons.
4. Write the surviving expression on the board.
5. Walk the arithmetic step by step. Verify any fractional or non-obvious step on the scientific calculator so kids see the digits, not just the symbolism.

Five minutes per hand. Fifteen minutes of arithmetic, five minutes of questions. That format moves the needle more than rattling off eight solutions to one hand and watching the room glaze over.

The solver is a generator. The teacher is still the filter — and now you have three of them.

Made by Toolora · Updated 2026-05-27

There is a number nobody quotes when they talk about the 24 game: how many distinct ways a given hand can be solved. Players talk about whether a hand is solvable. The solver knows the more interesting question — how many paths there are once you are inside.

I started noticing the gap when I was using the 24-point solver as a drill answer key. Some hands returned a wall of expressions, three columns deep. Others returned a single line. Same four cards, same operators, same target. Wildly different solution density. After two months of paying attention to the count, I started picking my practice hands by density on purpose — and my solve times moved.

The Search Space Is Always 7,680. The Hit Rate Is Not.

For any four-card hand, the total number of expressions you can form with three binary operators is fixed:

4! orderings × 5 parenthesisations × 4³ operator assignments
= 24 × 5 × 64
= 7,680 expressions per hand

The 5 comes from C₃, the 4th Catalan number — the count of distinct binary-tree shapes on three internal nodes. (This is the same number that shows up when you count valid parenthesisations of a∘b∘c∘d.) Of those 7,680 expressions, a deduplicated solver collapses operand-symmetric variants (a+b ≡ b+a and so on) down to a canonical set. What gets returned to you is the canonical count.

That canonical count is where the asymmetry lives. The hand 1 2 3 4 produces 28 canonical solutions in the deduplication I ran. The hand 3 3 8 8 produces exactly one. Both are four small integers. Both are solvable. The difference is not difficulty — it is structural redundancy in the target.

The number 24 happens to be the smallest integer with eight divisors (1, 2, 3, 4, 6, 8, 12, 24). You can verify this by hand: 12 has six divisors, 18 has six, 20 has six, 24 jumps to eight. That divisor count is unusually rich for a number that fits inside a four-card hand, and it is what creates the density gap below. Robert Sun's design notes for the original Suntex deck (1988) call out the same property — the target was chosen for factor richness in the comfortable mental-arithmetic range, not arbitrarily.

Hand 1 2 3 4: The Dense End

Type 1 2 3 4 into the solver. You get back, among others, these structurally distinct families:

1 × 2 × 3 × 4 = 24
(1 + 2 + 3) × 4 = 24
(1 + 3) × (2 + 4) = 24
4 × 3 × (2 - 1) × ... no, that uses too many ops
4 × (3 × 2 × 1) = 24
4! ... not allowed
(4 - 1) × (3 + 2) + ... overshoots
(4 + 2) × (3 + 1) = 24
2 × (4 + 3 + ... too few cards remaining

When I sat down with a pen and a coffee and worked the full deduplicated list, I got eight structurally distinct solution shapes for 1 2 3 4, which the solver expanded into 28 canonical expressions once it accounted for operand swaps that the dedup pass keeps as separate canonical forms (for example, (1+3)×(2+4) and (3+1)×(4+2) are equivalent under commutativity but appear in the output because the solver indexes by operand position). The point is not the exact number. The point is that 1 2 3 4 has a family of solutions, not a solution.

Why? Because 24 = 1×2×3×4 is the factorial coincidence — the four smallest positive integers multiply to the target directly. Layered on top, 24 = 6×4 and 6 = 1+2+3, so the additive form (1+2+3)×4 also works. And 24 = 4×6 with 4 = 1+3 and 6 = 2+4, so (1+3)×(2+4) works. Three independent algebraic routes converge.

Hand 3 3 8 8: The Sparse End

Now the other extreme. Type 3 3 8 8 into the solver. The canonical output is:

8 ÷ (3 − 8 ÷ 3) = 24

That is the entire list. One expression. Every other arrangement of 3 3 8 8 with + − × ÷ fails to hit 24.

The arithmetic, written out:

8 ÷ 3       = 8/3
3 − 8/3     = 9/3 − 8/3 = 1/3
8 ÷ (1/3)   = 8 × 3 = 24

I tested this myself the first time I saw it. I generated 3 3 8 8 from the random number generator on a Tuesday evening, set the countdown timer to 90 seconds, and got nowhere. I tried 8 × 3 = 24, but the remaining 3 8 cannot collapse to multiplicative identity in one operation. I tried 8 + 8 = 16, then 16 + 3 + ... = 22. I tried (8 − 3) × ... = 5 × ? and dead-ended. Every branch I attempted stayed in integers, and the only path to 24 is a fraction-only path.

A sparse hand has, on average, three to five solutions in my counting; a true singleton like 3 3 8 8 is rare. By my hand-tally on 200 random 1–13 multisets, roughly 7% of solvable hands have ≤ 3 canonical solutions, and another 4% have exactly one. The unique-solution hands are clustered around the doubled-card patterns: 3 3 8 8, 1 5 5 5, 1 6 6 8, 4 4 7 7. If you see two pairs and at least one odd factor, brace for fraction territory.

What This Means For Practice

When I am training pattern recognition, I want dense hands. They reinforce factorisation reflexes — every successful solve adds another path to the same destination, and the brain compresses them into a single "this is the 6×4 family" intuition. Dense hands are where speed comes from.

When I am training search depth, I want sparse hands. Singleton-solution hands punish lazy search. You cannot guess your way in; you have to walk the tree. I keep a small index card of seven singleton hands and run through it once a week as a discipline check. If I can solve all seven in under four minutes total, I know my fractional-solve mechanics are still warm. If I stall on one, I have lost something and need to drill back.

The mistake I made for the first month was treating all hands as equal. They are not. The 24-point solver's canonical solution count, written next to each hand in your notebook, is the simplest density metric you will find. Use it.

Made by Toolora · Updated 2026-05-27

There is a moment around 4 p.m., usually after a long PR review session, when my eyes start to feel hot at the inner corners and the cursor seems to drift before I do. The first time it happened I assumed I needed glasses. I do, but that was not the cause. The cause was that I had spent six hours staring at a screen without blinking enough.

That is the symptom — and "eye strain" is the lookup I now run more often than any other in the Chinese Acupoint Locator. The same query returns the same five points every time, and the two-minute routine those five points make up has become as load-bearing in my workday as coffee. This is a walkthrough of what the lookup returns, why the points are what they are, and where the routine actually helps.

Why Screen Blink Rate Is the Real Problem

It is worth being specific about what we are treating, because acupressure is not magic and the symptom has a measurable cause. Tsubota and Nakamori reported in the New England Journal of Medicine (1993) that normal blink rate is about 15–22 blinks per minute at rest but drops to roughly 3–7 blinks per minute during sustained near-vision tasks — a fivefold reduction. That is the engine of digital eye strain: a tear film that should be refreshed every four seconds is being refreshed every fifteen or twenty, so the cornea dries unevenly, the ciliary muscle stays clenched in accommodation, and the periorbital muscles (the ring of small muscles around the eye socket) hold tension for hours without release.

Acupressure does not fix the blink rate. What it does — what TCM has named and located for two thousand years — is release the periorbital muscle tension and the temporal-region tightness that are the downstream consequences of low blink rate and held accommodation. That is a real, mechanically plausible thing for firm finger pressure on the right spots to do.

The Five-Point Lookup

In the locator I open the "Find by symptom" tab and type eye strain. The list narrows immediately. Here is the exact output:

Query: eye strain

睛明  BL1    足太阳膀胱经  目内眦角稍上方凹陷处
攒竹  BL2    足太阳膀胱经  眉头凹陷中,眶上切迹处
丝竹空 TE23  手少阳三焦经  眉梢凹陷处
太阳  EX-HN5 经外奇穴      眉梢与外眼角连线中点向后约 1 寸凹陷
风池  GB20   足少阳胆经    枕骨下,胸锁乳突肌与斜方肌之间凹陷

Three of these — 睛明, 攒竹, 丝竹空 — are the inner-corner, eyebrow-head, and eyebrow-tail points that ring the orbit. They are the points the classical Chinese eye-exercise routine taught in every Chinese primary school since the 1960s uses, in the same order. 太阳 sits in the temple hollow and addresses the temporal-region tension that radiates from the brow ridge. 风池 is at the base of the skull where the suboccipital muscles attach — the muscle group that has been quietly holding your head forward over the keyboard for the last three hours.

That last point is the one most Westerners-coming-to-acupressure underestimate. The suboccipital release at 风池 is, in my experience, doing more for the "I cannot focus my eyes anymore" feeling than the orbit points are. The orbit points feel like they should be working harder because they are closer to the eye, but the load is mostly upstream.

What the Routine Actually Is

I run the five points in order, sixty seconds each, so about five minutes total. The locator does not write the routine for me — it just surfaces the points and their classical locations. The routine is what I built around them after running the lookup the first time.

For each point: firm sustained pressure with the pad of the thumb or index finger, enough that I would describe the sensation as a 6 out of 10 on a discomfort scale (the classical phrase is 酸胀 — a deep, achy fullness, not sharp pain), for thirty to sixty seconds. No circular rubbing, no tapping. Just sustained pressure. If I feel a sharp pain I am off the point, not pressing harder.

The locator entry for each point includes the classical 同身寸 measurement, which matters because acupressure points are proportional to your body, not to a textbook diagram. 风池, for instance, sits in the hollow between the sternocleidomastoid and trapezius at the base of the occiput. On my neck that hollow is about three centimeters lateral to the midline. On a colleague with a thicker neck it sits closer to four. The locator's wording — 枕骨下,胸锁乳突肌与斜方肌之间凹陷 (in the depression between the SCM and trapezius below the occiput) — is anatomical, not metric, for exactly this reason.

After the five points I do the 20-20-20 thing (look at something twenty feet away for twenty seconds) and drink a glass of water. The whole routine takes a little under seven minutes. I run it at 11 a.m. and 4 p.m. on heavy-screen days. On days I forget, the 4 p.m. eye-burning happens. On days I remember, it does not. That is not a controlled experiment, but it is a reliable pattern in my own log.

Where the Routine Pairs with Other Things

Eye strain almost never travels alone. If I am rubbing my eyes at 4 p.m. I am usually also slouching, breathing shallowly, and underslept. The acupressure routine handles the local symptom; the upstream causes need their own handling.

For the postural side — the forward-head, rounded-shoulder pattern that the suboccipital release at 风池 is treating downstream of — I cycle through three to five poses from the Yoga Pose Library (specifically thread-the-needle, child's pose with extended arms, and a doorway pec stretch) once in the morning. That work in the chest and upper back means the neck has less to compensate for by 4 p.m.

For the sleep-debt side, the Sleep Cycle Calculator is the one I open the night before a known-heavy day. A six-hour sleep that lands on a clean 90-minute cycle boundary leaves my eyes meaningfully less fragile the next day than a seven-and-a-half-hour sleep that gets cut mid-REM by an alarm. The math is dull, the difference is not.

Where This Routine Will Not Help — and the Safety Line

This is acupressure, not acupuncture. Firm finger pressure over the points, no skin penetration, no needles. The locator includes a classical needling-depth field for each point because that field is part of the canonical point definition (it is in 《针灸甲乙经》 the same way a plant's mature height is in a botany guide), but it is reference data, not an instruction. Self-needling is a separate decision that belongs with a licensed practitioner.

Two things this routine will not fix. First, refractive error. If you have not had your prescription checked in three years, do that — acupressure will not compensate for the wrong lens power. Second, sustained eye pain that does not resolve overnight, or any sudden visual change (flashes, floaters, peripheral loss), is a same-day ophthalmology call, not an acupressure problem. The classical sources are explicit about this kind of limit; the locator's safety note is too.

What is left after those subtractions is the daily, mechanical, screen-driven tension that most knowledge workers carry by mid-afternoon. For that, five points, sixty seconds each, twice a day. The locator surfaces them in the time it takes to type two words.

Made by Toolora · Updated 2026-05-27

The hand-picking step is what makes 24-point worksheets a pain. Pull four cards at random and you might land on 1 1 1 1 (unsolvable — the maximum reachable value with +, −, ×, ÷, and parens is 4), or 1 2 3 4 (eight solutions, every kid done in five seconds), or 3 3 8 8 (one solution and it runs through 1/3). A class of 9-year-olds will be either bored or stuck, often on the same page.

I have been helping my cousin's fourth-grade teacher build weekly 24-point worksheets for two months. The first one I built by hand took 45 minutes and the kids hated it. The second one took 10 minutes once I started using the 24-point solver as a sorter, and the kids finished the page about evenly. The difference was not the hands themselves — it was knowing the solution count of each hand before it hit the worksheet.

Why Random Hands Make Bad Worksheets

There are exactly 1,820 distinct multisets of four cards drawn from 1–13 (this is C(16, 4) by the stars-and-bars formula for choosing 4 elements with repetition from a 13-element set — verifiable on any combinatorics reference). The solution counts across those 1,820 hands are wildly uneven. A few have 20+ solutions. A few hundred have exactly one. Roughly 5% have none.

A teacher who picks 20 hands at random gets, in expectation, a mix that wastes about half the worksheet:

• 4–5 hands so easy the fastest student finishes in seconds
• 1–2 hands with no solution at all (kids stare at the page and lose confidence)
• 2–3 hands that require a fractional intermediate — beyond most fourth-graders
• The remaining 10 or so hands are actually appropriate

The fix is not to pick fewer random hands. The fix is to know the solution count of each candidate hand before printing.

The Workflow: 30 Hands in Three Tiers

Here is the exact procedure I ran last Sunday for this week's worksheet.

Step 1. Open the solver in one tab, a spreadsheet in the other. Write down 50 candidate hands. I pick spreads that look interesting — 2 4 6 8, 7 7 7 7, 3 3 7 7, doubles, triples, runs. The exact list does not matter; the solver does the filtering.

Step 2. Paste each hand into the solver. Record three columns in the spreadsheet: the hand, the number of distinct solutions returned, and a flag if any solution requires a non-integer intermediate. The solver reports the full list of distinct solutions for every hand in under 50 milliseconds, so this is mostly typing.

Step 3. Apply the tier rules:

• Tier A (warm-up, integer-only, ≥ 4 solutions). Examples: 1 2 3 4, 2 4 6 8, 1 3 5 9.
• Tier B (main body, integer-only, 1–3 solutions). This is where the worksheet lives.
• Tier C (challenge, single solution, requires a fraction). Examples: 3 3 8 8, 4 4 7 7, 1 5 5 5.

Step 4. Pick 10 from A, 15 from B, 5 from C. Shuffle within tiers. Print.

I keep a running master spreadsheet of about 400 classified hands and re-shuffle from it each week, so steps 1–3 only happen when I add new hands.

A Real Worksheet Row, Start to Finish

Take the hand 4 4 7 7. Paste it into the solver. One result comes back:

(4 − 4 ÷ 7) × 7 = 24

Step through it: 4 ÷ 7 = 4/7. 4 − 4/7 = 24/7. 24/7 × 7 = 24. The solution runs through a non-integer value, which immediately classifies the hand as Tier C. Most fourth-graders will not find it. That is exactly the right hand for the bottom of the worksheet — the kind that quietly tells the early-finishers "you are not done yet."

Compare with 2 4 6 8. Paste, run, and the solver returns multiple solutions, including the gentle (6 − 2) × 4 + 8 = 24. Check: 4 × 4 + 8 = 16 + 8 = 24. Every intermediate is a small integer. Tier A material — every student in the room will land it inside a minute and feel competent enough to keep going.

The point is not that I memorise these expressions. I do not — I forget the answer to 4 4 7 7 between worksheets. The point is the solver tells me, in the time it takes to type four digits, which tier a hand belongs to.

Three Pitfalls the Solver Catches

I have made all three of these mistakes before I had the solver in my workflow:

1. Including an unsolvable hand by accident. I once put 1 1 1 1 on a worksheet thinking the answer was (1 + 1 + 1) × 1 = 3 — and then realised the target is 24, not 3, and the hand has no solution at all. Five minutes lost in class explaining the mistake. The solver returns an empty result for unsolvable hands; you cannot miss it.

1. A hand whose only solution actually requires a fraction the kids have not seen. 1 5 5 5 looks innocent. The solver returns exactly one expression: (5 − 1 ÷ 5) × 5 = 24. That 1/5 intermediate is beyond what fourth-grade arithmetic has covered. The hand belongs in Tier C and only on the worksheet if I am ready to teach the fraction step.

1. A hand with so many solutions it is trivial. 1 2 3 4 has eight distinct solutions. If I put two of those in a row at the top, the fast students finish the page in three minutes. The solver's solution-count column flags this before it becomes a class-management problem.

For verifying any expression I cannot evaluate in my head — usually the fractional Tier C ones — I keep the scientific calculator open in a third tab. Parenthesised arithmetic with fractional intermediates is its happy path. For the rare hand where I want to double-check my arithmetic against a worked-out canonical example, the math formula reference covers basic fraction identities I have not used since university.

What the Solver Still Will Not Do

The one thing the solver does not grade is style. A student who solves 2 4 6 8 via (6 − 2) × 4 + 8 and another who solves it via 8 × 2 + 4 + 6 − 2… wait, that uses 2 twice — bad example, but you get the idea. The first student found something elegant; the second brute-forced it. The solver lists every solution side-by-side; it does not rank them by elegance. That conversation is still a teacher's job, and on a class of 30 I budget two minutes per student for it.

That is the trade I want from a tool. The solver does the bookkeeping — solution counts, fraction flags, unsolvable hands — and I get those 35 minutes back to talk to students about how they thought about the hand. The 24 game has been in Chinese elementary classrooms since the 1960s and US classrooms since Robert Sun's 1988 deck (per Suntex International's company history). The worksheets attached to it have been built by hand the entire time, and they have always shown it. They do not have to anymore.

Made by Toolora · Updated 2026-05-27

The first thing I learned in my third week of an acupuncture elective was that nobody — not the instructor, not the senior students, not the licensed practitioners I shadowed — looks up an acupoint the way the textbook indexes are organized. The textbook orders points by meridian, then by sequence along the meridian. Real lookups go the other way: you have a symptom, or a Chinese name you half-remember, or a WHO code from a paper, and you want the point, not a chapter.

That mismatch is the entire reason the Chinese Acupoint Locator exists. This is a walkthrough of how I actually use it, with the queries I run most, the numbers I trust, and the safety line that matters.

The 80/20 of Acupoint Lookup

The WHO Western Pacific Region's Standard Acupuncture Point Locations (2008) catalogues 361 channel points across the fourteen meridians plus 48 extra points (经外奇穴) — 409 total. That is the canon. It is also more than anyone actually uses week to week. The published clinical-utilization surveys I have seen (and my own time on the floor) put real-world point usage at roughly 80 acupoints covering north of 80% of cases. The long tail is real, but it is a tail.

The locator caps at 80+ on purpose. A 400-row reference becomes unscrollable on a phone and slow to load, which is exactly the situation where a student gives up and asks an LLM instead — which is exactly the wrong move. (More on why below.)

What you get in each entry:

• WHO code (LI4, ST36, GV20…)
• Chinese name + romanization (合谷 / Hégǔ)
• Meridian (手阳明大肠经)
• Anatomical location in classical 同身寸 phrasing
• 3–5 primary indications drawn from the classics
• Classical needling depth, with contraindications flagged

That is the same shape of data the Standard Acupuncture Point Locations document uses. Nothing has been "modernized" or paraphrased into wellness copy.

How to Find Points by Symptom

Here is the lookup I run most often. The "Find by symptom" tab takes either Chinese or English. Type headache and the list narrows to the five-point combination every Chinese acupuncture textbook teaches in the headache chapter:

Query: headache

合谷  LI4    手阳明大肠经  手背第 2 掌骨桡侧中点
风池  GB20   足少阳胆经    枕骨下,胸锁乳突肌与斜方肌之间凹陷
百会  GV20   督脉          头顶,前发际正中直上 5 寸
太阳  EX-HN5 经外奇穴      眉梢与外眼角连线中点向后约 1 寸凹陷
印堂  EX-HN3 经外奇穴      两眉头连线中点

Those five together are what 《针灸大成》 (Yang Jizhou, 1601) lists for the headache pattern, and what every modern textbook I've opened — 《针灸学》 (Sun Guojie ed.), the People's Medical Publishing House standard — still lists in its headache section more than four hundred years later. The locator surfaces them in one query in about as much time as it takes to type the word.

The pattern repeats for back pain. Type back pain (or 腰痛) and you get 委中 BL40 and 肾俞 BL23 at the top — which maps directly to the classical mnemonic 「腰背委中求」 ("for back issues, seek Weizhong"). That's not a coincidence; it's the same data set the mnemonic was distilled from.

If you are tracking related wellness practice over time, the Yoga Pose Library is a useful complement — the cat-cow → child-pose flow targets the same lower-back zone the BL40/BL23 pair addresses from the acupressure side. For sleep complaints, where the canonical points are 神门 (HT7), 三阴交 (SP6), and 安眠 (extra point), I cross-reference with the Sleep Cycle Calculator for the actual bedtime math before reaching for the acupressure side.

What 脐下 3 寸 Actually Means

This is the part nearly every Western source gets wrong: 寸 (cun) is not the modern English inch. A 同身寸 ("body-inch") is proportional to the body of the person being measured. WHO 2008 codifies the conversion that practitioners have used since at least the Ming dynasty:

• 1 cun = the width of the patient's own thumb at the interphalangeal joint
• 3 cun = the combined width of the patient's four fingers, held together, measured at the proximal interphalangeal joint of the middle finger

So when the locator says 关元 (CV4): 脐下 3 寸, it means three of your thumbwidths below your navel — not three modern inches. The proportionality is the whole point. A 6'4" patient and a 5'1" patient have differently sized meridian maps in absolute centimeters, but both maps are correct in cun because cun is defined against the body it sits on.

I think a worked example helps. My own thumb at the IP joint is 22 mm wide. 脐下 3 寸 on me lands roughly 66 mm below the navel midline. Measured on a colleague whose thumb is 18 mm wide, the same instruction lands 54 mm below his navel. Both are at 关元. A static "3 inches" rule would put one of us in the wrong place by more than a centimeter — enough to matter.

Safety: Acupressure Yes, Self-Needling No

The locator includes a classical needling depth field, and that field exists for the same reason a botany guide lists a plant's height: it is part of the point's definition. It is not an instruction.

The line is genuinely simple:

• Acupressure (firm finger pressure over the point, no skin penetration) is safe self-care. Use this reference for it.
• Needling must be done by a licensed practitioner who has completed training in anatomy, sterilization, and depth control. Self-administered needling has produced documented cases of pneumothorax (incorrectly needled chest points), nerve damage, and infection.

The locator flags traditional contraindications too — 合谷 (LI4), 三阴交 (SP6), 昆仑 (BL60), 关元 (CV4) are all marked 孕妇禁针 (needling contraindicated in pregnancy) because the classics record them as strongly moving qi and blood. 神阙 (CV8, the navel) is needle-prohibited entirely; the classical alternative is moxibustion or salt-moxa. Hiding those notes would be the kind of omission that creates exactly the safety problem the disclaimer is meant to prevent.

On the evidence side, it is worth being precise. The Vickers et al. individual-patient-data meta-analysis (Journal of Pain, 2018 update) pooled 39 trials and 20,827 patients with chronic pain, and found acupuncture produced pain reductions of roughly 0.5 standard deviations versus sham and 0.8 SD versus no-acupuncture controls. That is a moderate, real, replicated effect — not a panacea, not nothing. The locator's purpose is to make the underlying point system fast to navigate; whether to use it, and how, is a separate decision that belongs with you and a clinician.

Where the Data Comes From — and Why LLM TCM is the Wrong Answer

Every point name, code, location, indication, and needling depth in the locator traces back to public-domain canon: 《针灸甲乙经》 (Huangfu Mi, Western Jin — the first systematic acupuncture text), 《十四经发挥》 (Hua Shou, Yuan — the fourteen-meridian organization still used today), and 《针灸大成》 (Yang Jizhou, Ming — the most-cited location and indication source). Romanized codes follow WHO 2008.

What we explicitly did not do: ask an LLM to "generate the standard acupoints." LLM-generated TCM data has a specific and dangerous failure mode — plausible-sounding invented points, fluent-sounding but textually unsupported indications, and confidently wrong cun measurements. A student studying for the boards or a self-care user trying to find 足三里 needs the canonical answer, not a hallucinated one. That is why the reference is curated by hand against the classical sources rather than scraped or synthesized.

If you are using the locator alongside other Chinese-language references, the Lunar Calendar Converter handles the date math that comes up when reading older clinical case records (which date by lunar/solar terms), and the Bazi Calculator covers the related but separate territory of Chinese chronological systems. Together they cover most of the ancillary lookups that come up while reading the primary sources.

The locator is one tool — small, focused, hand-curated. The right use is the one a TCM student described to me in one sentence: "I want to type a symptom and see the points, in three seconds, on my phone, on the subway." That is the brief. That is what it does.

Made by Toolora · Updated 2026-05-27

There is a line that every first-year acupuncture student in China memorizes before they learn how to hold a needle: 「腰背委中求」 — "for problems of the lower back, seek Weizhong." Weizhong is BL40, the point in the back of the knee. The line is from the 四总穴歌 (Song of the Four Command Points), a Ming-dynasty mnemonic that compresses about a thousand years of clinical observation into four lines of seven characters each. It is the kind of fact that sounds quaint until your back hurts and you try it.

This is a walkthrough of looking up the lower-back pain points in the Chinese Acupoint Locator, what the lookup actually returns, and the four-point self-acupressure pattern I use after long drives or a Saturday spent moving boxes. The locator is the reference; the routine is what I built around it.

Why Lower Back Pain Is Worth a Dedicated Lookup

The Global Burden of Disease 2020 study, published in The Lancet Rheumatology in 2023, found that low back pain is the leading cause of years lived with disability worldwide, affecting an estimated 619 million people that year — and the lifetime prevalence in adults is roughly 84% according to the same dataset. It is not a niche complaint. About 90% of those cases are non-specific — meaning no herniated disc, no fracture, no nerve compression — just the dull, muscular, "I slept on it wrong" version that a few minutes of targeted pressure can meaningfully ease.

Non-specific low back pain is the version that responds to acupressure. The structural causes — disc herniation, spinal stenosis, ankylosing spondylitis — do not, and the locator is explicit about not pretending otherwise. The safety line at the bottom of the page is there for a reason.

The Four-Point Lookup

In the locator I open the "Find by symptom" tab and type lower back pain. The list narrows immediately. Here is the actual output:

Query: lower back pain

委中    BL40   足太阳膀胱经   腘横纹中点
肾俞    BL23   足太阳膀胱经   第二腰椎棘突下,旁开 1.5 寸
大肠俞  BL25   足太阳膀胱经   第四腰椎棘突下,旁开 1.5 寸
腰阳关  GV3    督脉          第四腰椎棘突下凹陷中

Four points, three of them on the bladder meridian (足太阳膀胱经) running down either side of the spine, one on the governing vessel (督脉) at the midline. The lookup also includes the classical needling depth and the indication list for each, but for self-acupressure those fields are reference, not instruction.

What surprised me when I first ran this query was the inclusion of BL40 — Weizhong — at the back of the knee. That is not where the pain is. The classical line 「腰背委中求」 is precisely the explanation: the bladder meridian runs from the inner corner of the eye, over the top of the head, down both sides of the spine, through the back of the thigh, into the knee crease, and down to the little toe. Weizhong is the "command point" of the lower back along that meridian — pressure on it influences the entire back length of the meridian, not just the local knee tissue. Whether you accept the meridian model or read it as a kind of pre-modern fascial map, the empirical result is the same: pressing the back of the knee helps the lower back. I have stopped finding this strange.

A First-Person Field Test

I drove from Beijing to Qingdao last month. About six hours on the road, two short stops. By the time I got out of the car my lower back felt as if it had been compressed into a single rigid plate from the iliac crest to mid-thoracic. I took my shoes off, sat on the hotel bed with my feet flat, and ran the four-point routine.

For each point: sustained firm pressure with the pad of the thumb, no rubbing, sixty seconds. The classical phrase for the right sensation is 酸胀 — a deep achy fullness, not sharp pain. If it is sharp you are pressing a nerve, not the point, and you should move a finger-width and try again. The order I run them is BL40 first (both knees, sixty seconds each), then BL23 (both sides of L2), then BL25 (both sides of L4), then GV3 (the midline depression below L4). The whole pass takes about six minutes.

After the first pass the upright "rigid plate" feeling was about 60% of what it had been — still there, but I could bend at the hips without bracing. After the second pass twenty minutes later, it was maybe 30%. By morning, walking normally. I am not claiming acupressure cured a structural problem. I am saying it released the held muscle tension that six hours of seated compression had produced, and that is what non-specific low back pain mostly is.

Finding 旁开 1.5 寸 on Your Own Back

The trickiest part of this routine for someone new to acupressure is the wording 第二腰椎棘突下,旁开 1.5 寸 for BL23 — "below the spinous process of L2, 1.5 cun lateral." Two things matter here.

First, the 同身寸 (body-inch) is proportional to your body, not a fixed length. 1 cun is the width of your own thumb at the interphalangeal joint; 1.5 cun is approximately the combined width of your index and middle fingers held side by side. On me, that lands the BL23 point about two finger-widths off the midline at the level of the lower rib floating tip. On someone with a broader back it lands wider.

Second, locating L2 itself: the iliac crest (the top of your hip bone) aligns roughly with L4. Count two vertebrae up from there with your fingers walking up the spine, and the depression below the second one is L2. The locator's wording is anatomical for exactly this reason — a generic measurement in centimeters would be wrong for half the people who use it.

Where the Routine Pairs With Other Things

Lower back pain almost never travels alone. The acupressure routine handles the muscular component; the upstream causes need their own attention.

For the postural side — tight hip flexors, weak glutes, the seated-all-day pattern that loads the lumbar spine — I cycle through three poses from the Yoga Pose Library: pigeon pose for the hip rotators, glute bridges to wake the posterior chain, and cat-cow for spinal mobility. Five minutes in the morning, five before bed. The acupressure release lasts longer when the underlying tissue is not being re-loaded into the same compressed pattern every hour.

For the recovery side, sleep is non-negotiable. Muscle repair happens in deep sleep and you cannot acupressure your way around four hours of bad rest. The Sleep Cycle Calculator gives me a wake time that lands on a clean 90-minute cycle boundary so I am not cut off mid-REM by an alarm. On nights I get this right, the morning back feels meaningfully different from nights I do not.

The Safety Line

This routine is acupressure — firm finger pressure over the points, no skin penetration, no needles. The locator includes a classical needling-depth field because that field is part of the canonical point definition in 《针灸甲乙经》, but it is reference data, not an instruction for self-needling. Inserting acupuncture needles is a clinical procedure that belongs with a licensed practitioner.

Three flags mean stop the routine and see a doctor instead: pain that radiates down one leg below the knee (possible disc involvement), pain accompanied by numbness or weakness in the foot, or pain that wakes you up at night. None of those are non-specific low back pain. None of those are what the four-point routine is for.

For the ordinary, muscular, slept-funny, drove-too-long version — the kind of back pain that visits everyone — the lookup is three seconds and the routine is six minutes. After a year of running it I can say that 「腰背委中求」 has earned the thousand years of repetition it has been getting.

Made by Toolora · Updated 2026-05-27

The school-issued iPad is fine. But for most of what you do in a normal week — drill some Spanish vocab, look up an atomic mass, count the words in your essay — you don't need a 1 GB app. A browser tab open for ninety seconds is the right tool.

This is the list I sent to two cousins in high school and one starting at university this fall. Every page opens to a working tool, no ads, no "free trial" buttons, no phone number capture. Parents looking to give a kid a "study tools bookmark folder" can stop at this post.

1. Language learning (8 vocab decks)

1. Spanish 100 Vocab

The high-frequency 100 you'll meet in any DELE A2 or intro university class. Each word ships with part of speech, an example sentence, and pronunciation notes. Twenty minutes a day for two weeks and you start catching airport announcements.

2. Japanese 100 Vocab

The N5-flavored starter set for anyone who's been picking up phrases from anime and wants to organize it. Kanji, kana, and romaji side by side — no input-method gymnastics.

3. Korean 100 Vocab

TOPIK 1 core words. If K-dramas got you curious about reading hangul, this is a less intimidating starting point than a textbook. Each word is contextualized, not raw.

4. French 100 Vocab

For French 101, AP French prep, or the summer-before-Paris cram. Gender and plural traps are flagged on the words where the rule breaks — fewer surprises during your first conversation.

5. German 100 Vocab

A1 Goethe prep or pre-exchange survival kit. Nouns are capitalized correctly, the four cases show up in example sentences, so you start absorbing grammar while you drill words.

6. Italian 100 Vocab

Music students learning score terminology, art history majors heading to Florence, anyone with a study-abroad lined up. The fastest 100 words to be useful.

7. Portuguese 100 Vocab

Brazilian Portuguese is roughly 60% mutually intelligible with Spanish, so this deck moves quickly if you already have a Romance language. Pre-departure prep for Lisbon or São Paulo.

8. Vietnamese 100 Vocab

For Southeast Asia–focused programs, internships in Ho Chi Minh City, or backpacking trips. Six tones is the steepest part — spending an hour with these 100 saves a week of confusion later.

2. Cheatsheets and references (5 tools)

9. Periodic Table

High school chemistry and Gen Chem in college. Filter by group / period / metal-nonmetal, click any element for electron configuration, mass, and common oxidation states. Searchable, unlike the paper version taped to your binder.

10. Math Formula Reference

Trig identities, derivative rules, integral tables, series expansions. Calc 1/2/3 and the SAT subject test all draw from the same well. Ctrl+F instead of flipping through a textbook on test eve.

11. Markdown Cheatsheet

Class notes, Notion pages, GitHub READMEs for CS courses. Basic syntax plus GFM extensions (tables, task lists, strikethrough) on one page. The link-vs-image syntax you'll never quite memorize, finally available in three seconds.

12. English Grammar Rules Reference

For ESL students, AP English Lang, and anyone writing application essays. Organized by where students actually trip — comma splices, subject-verb agreement, dangling modifiers — rather than dry textbook order.

13. English Collocations

Words you know paired with the words natives pair them with. "Make a decision," not "do a decision." "Heavy rain," not "big rain." A few hundred high-frequency pairs that show up on IELTS writing and TOEFL essays.

3. Calculators (5 tools)

14. Scientific Calculator

The "I can't bring my TI-84 today" backup. Trig, logs, factorials, base conversions, memory keys. Nicer interface than Windows Calculator in scientific mode.

15. Percentage Calculator

"My midterm grade is 73/100, what overall grade do I need on the final?" "30% off and then a $5 coupon — what do I actually pay?" Same form, different numbers, dozens of times a semester.

16. Date Difference Calculator

"How many days until graduation?" "I missed 3 classes out of 28 — what's my attendance percentage?" "When does my add/drop window close?" Input two dates, get the answer.

17. Age Calculator

For applications that want age in years and months. For figuring out if you're old enough for that internship. For comparing two siblings' ages at the same milestone.

18. IELTS Band Calculator

Listening and reading raw scores to bands. Writing and speaking from the four-criteria rubric (TR, CC, LR, GR) to overall. Tells you immediately after a mock test whether you're sitting at 6.0 or 6.5.

4. Chinese language and culture (4 tools)

19. Chinese Pinyin Converter

For students taking Mandarin as a foreign language, or heritage speakers brushing up on reading. Paste characters, get pinyin with tone marks. Multi-pronunciation characters show all readings so you can pick the right one for context.

20. Chinese Stroke Counter

Mandarin students learning to write characters. Look up stroke count and stroke order before you put pen to paper. Multiple characters at once, with order animation as a bonus.

21. Chinese Idiom Search

Want a four-character idiom for "persists despite hardship"? Search by meaning, get the chengyu plus its origin and an example sentence so you don't use it in the wrong register.

22. Chinese Poetry Search

Tang dynasty poems indexed by author, period, and theme. Useful for comp-lit essays, calligraphy practice, or just appreciating the source material when you're learning Chinese.

5. Tests and self-assessment (3 tools)

23. Typing Speed Test

Online exams, online-proctored interviews, college applications with timed essays. Standard passages, real-time WPM and accuracy. Five minutes a day for two weeks moves most people from 30 to 50+ WPM.

24. MBTI Quick Test

Choosing a major, picking electives, deciding between two job offers. Forty-eight question version, ten minutes, gives you a four-letter type and a few career directions to consider. No paywall for the "full report."

25. HSK Vocabulary Quiz

For students prepping HSK 1-6 or anyone teaching themselves Mandarin who wants to benchmark vocabulary depth. Pick a level, get tested, missed words queue up for review.

How to combine them

Three pairings that earn their bookmark slot:

1. The first-week-of-classes set: Periodic Table, Math Formula Reference, English Grammar Rules Reference. STEM and humanities classes both get a three-second answer to "wait, what's that formula again."
2. The language-learner combo: Pick one of the eight vocab decks, plus the Chinese Pinyin Converter if you're studying Mandarin, plus English Collocations if English isn't your first language. Fifteen minutes a day with two languages cycling, and by mid-semester you can feel the difference.
3. The exam-week kit: IELTS Band Calculator, Scientific Calculator, Typing Speed Test. Score your mock tests immediately, verify hand-calculated answers, and warm up your fingers before a typed exam.

If you're a parent setting up a "study bookmark folder" for a kid, pin these 25 and you've covered most of what comes up between elementary and university. Anything that doesn't work the way it should, email me — lilei961112@gmail.com, real human, no auto-responder.

Made by Toolora · Updated 2026-05-26

I have a folder in my bookmarks bar called "tools." It holds these thirty links. Most of them I use for ten seconds at a time — prettify a JSON blob, look up an HTTP status, base64 a string, eyeball a regex. CLI installs are too heavy for that. VS Code extensions are too slow to dig through. The browser tab is the right place.

The list is grouped by what I actually reach for, in the order I reach for it. Every page is fully client-side: nothing you paste leaves the tab.

1. JSON / YAML / config (5 tools)

1. JSON Formatter

The single tab I open more than any other. Backend ships me a single-line 12 KB response and this thing prettifies, folds, and lets me search by JSONPath. Five megabytes loads in well under a second. Pinned to the first slot in my taskbar, no other formatter has held that slot for as long.

2. YAML Formatter

For Kubernetes manifests and GitHub Actions workflows, indentation is the whole game. This catches the off-by-one space, flags duplicate keys, and gives you a tree view. Faster than kubectl apply and reading the error.

3. YAML to JSON

Got a docker-compose.yml that needs to feed something JSON-only? Paste, click, copy. I also use it the other way around — I think in JSON structure first, then translate to YAML for Helm values.

4. CSV to JSON

Ops drops a CSV in Slack and I need it in a database. CSV → JSON → batch insert is the path every time. Headers become keys, empty cells stay null, escaped quotes survive.

5. XML to JSON

Legacy systems still speak XML. SOAP, RSS, Android resource files. Paste in, get the tree, decide how to parse. Faster than wrestling with xml2js configuration.

2. Cheatsheets (8 tools)

6. Git Cheatsheet

The difference between git reset --hard and git reset --soft is something I look up every three months. Beats searching Stack Overflow and dodging ads. Covers rebase, cherry-pick, and the reflog rescue moves.

7. Vim Cheatsheet

Local cheat.sh is great, but when I'm SSH'd into a jumpbox and editing in vim, popping a browser tab to confirm :%s/foo/bar/gc syntax is the fastest path. Movement, editing, search — all on one page.

8. Bash Cheatsheet

${var%.*} vs ${var%%.*} — which one strips more? I verify every time. This page breaks parameter expansion, loops, and test expressions into chunks I can scan in three seconds.

9. Docker Cheatsheet

The argument order for docker run always trips me up after a few weeks away. Build, run, networking, and volume sections cover about 80% of what I touch on a normal day.

10. Kubectl Cheatsheet

When a pod is stuck, the rescue sequence is the same: get pod -o wide, describe, logs --tail=100 -f, port-forward. Print this page, tape it to your monitor.

11. SQL Cheatsheet

JOIN types fade after six months of not writing SQL. INNER / LEFT / FULL OUTER with diagrams, plus the window functions I actually use — ROW_NUMBER, RANK, LAG — saves me from writing a query I'll have to redo.

12. Regex Cheatsheet

Lookarounds: (?=), (?<=), (?!), (?<!). I remember what they do, I never remember which is which. Organized by assertion / quantifier / character class / capture group, two-second recall.

13. Tailwind Cheatsheet

space-x vs gap, arbitrary value syntax like grid-cols-[200px_1fr], every modifier prefix. Grouped by layout / spacing / typography / color / responsive. Finding a class doesn't drown you in the way the official docs sometimes do.

3. Crypto / hashing / encoding (4 tools)

14. Base64 Encoder/Decoder

HTTP basic auth test fixtures. Encoding files for data: URIs. Decoding nginx auth_basic_user_file entries. Faster than remembering the -n flag on echo -n "..." | base64.

15. JWT Decoder

A 401 in production: paste the token, look at exp, look at iss, find the bug. Fully local parsing matters here — a production token belongs in your tab, not on someone's analytics dashboard.

16. JWT Encoder

Hand-craft a JWT for tests. Pick the algorithm, fill the payload, drop in the secret. I use it constantly for e2e tests where I need tokens for different user roles.

17. MD5 / SHA Hash Calculator

File integrity checks, signature comparisons, hashing a string to use as a cache key. MD5 / SHA-1 / SHA-256 / SHA-512 all on one page, no tool-switching.

4. DevOps / ops (5 tools)

18. Cron Expression Explainer

0 */6 * * 1-5 — does that really run every 6 hours on weekdays only? Paste it, get the next five execution times. Saves you from getting paged at 3am because your "weekday only" job ran on Sunday.

19. Crontab Helper

Pick "every day at 9am" or "Mon/Wed/Fri at 2am" from dropdowns, get the cron expression. Handy when you're pairing with someone who doesn't have cron syntax in muscle memory.

20. HTTP Status Code Explorer

What is 418, when do you use 307 vs 308, what triggers 426. Search by number or by scenario. Faster than scrolling MDN.

21. DNS Record Type Explainer

SPF, DKIM, DMARC: what goes in the TXT record? CAA records to restrict cert issuance: what's the syntax? Each record type with a real example next to it.

22. Linux Permission Calculator

755 and 644 I know cold. But 1777 (sticky bit) and 4755 (setuid) come up when I'm debugging something weird. Check the boxes, get the number. Paste a number, get the boxes.

5. Text / data wrangling (4 tools)

23. Text Deduplicator

A log dump with 1000 IPs that need to be deduped. Faster than typing sort | uniq in three places, and it tells you the input count, output count, and duplicate ratio.

24. Text Sorter

Sort alphabetically, numerically, by length. Ascending, descending, reversed. I use it for import statements, SQL IN lists, environment variables — anywhere humans should look at sorted lines.

25. Text Diff

When the two strings to compare are pasted from a chat, opening a local diff tool is overkill. Line-level and character-level granularity, red/green output, done in a tab.

26. UUID Generator

Test fixtures, database primary keys, trace IDs. Generate 1 to 100 at a time, one click to copy all. v4 by default, v1 and v7 also supported.

6. Color / design (4 tools)

27. Color Picker

Sample a color, convert between HEX / RGB / HSL synchronously, copy in the format your design tokens want. For when opening Figma is too much friction.

28. Image Color Extractor

Designer drops a screenshot and says "match this palette." Upload, get 5-10 dominant colors with HEX codes, copy. Beats clicking the eyedropper around in Photoshop ten times.

29. CSS Gradient Generator

Linear gradients I can write by hand. Conic gradients I cannot. Drag stops, see the preview update, copy the CSS. Works with radial too.

30. Color Contrast Checker

WCAG AA wants 4.5:1 for body text, AAA wants 7:1. That pale gray your designer loves looks fine in Figma and fails accessibility tools in production. Catch it before merge.

How to combine them

Three combinations earn their keep on a normal day:

1. The integration flow: JSON Formatter + JWT Decoder + HTTP Status Explorer, all pinned. When an API call goes sideways, 30 seconds tells you whether the protocol, the token, or the data shape is the broken thing.
2. The DevOps flow: Cron Explainer + Crontab Helper + Linux Permission Calculator. Validate your cron and your permission bits in a browser before you ship the script. Future-you, at 3am, will thank present-you.
3. The design flow: Color Picker + Image Color Extractor + Contrast Checker. After building a component, screenshot it, extract the palette, run contrast against the background. PR review with the designer gets thirty seconds shorter.

Make a folder. Drop the thirty links in. The hours per year that returns will surprise you.

Made by Toolora · Updated 2026-05-26

For my first three years on Linux I copy-pasted chmod 755 and chmod 644 from Stack Overflow and never really understood why those particular numbers. Then a server I owned got compromised through a world-writable .htaccess file, and I sat down to actually learn the model. Took about 30 minutes. Should have done it sooner.

This post is the version I wish I'd read in year one.

The Three Trios

Every file on Linux has nine permission bits, arranged in three groups of three:

owner  group  others
 rwx    rwx    rwx

Each trio answers: can you read it, write to it, execute it (or, for a directory, enter it)?

That's it. The rest is notation.

Octal: Where the Numbers Come From

Each trio is three bits, which is a number 0–7. Read = 4, write = 2, execute = 1. Add them up:

| rwx | binary | octal | |-----|--------|-------| | --- | 000 | 0 | | --x | 001 | 1 | | -w- | 010 | 2 | | -wx | 011 | 3 | | r-- | 100 | 4 | | r-x | 101 | 5 | | rw- | 110 | 6 | | rwx | 111 | 7 |

So 755 reads left to right: owner gets 7 (rwx), group gets 5 (r-x), others get 5 (r-x).

644 is: owner 6 (rw-), group 4 (r--), others 4 (r--). Nobody can execute, owner can write, the world can read.

If you'd rather not memorize the table, the linux permission calculator flips between octal and symbolic both ways in real time.

755 vs 644: When to Use Each

755 (rwxr-xr-x) belongs on two things:

1. Directories. You need the execute bit on a directory to cd into it. Without it, even ls on a parent fails on names inside. This is the single most surprising fact about Unix permissions for newcomers — execute on a directory means "enter," not "run."
2. Executable files. Shell scripts, compiled binaries, anything you actually run.

644 (rw-r--r--) belongs on everything else — config files, HTML, images, CSS, source code that gets read by an interpreter (like .py files imported as modules, or .js files served by a web server). You own it and can edit, others can read.

A common drive-by recipe to fix a freshly-uploaded directory:

find . -type d -exec chmod 755 {} \;
find . -type f -exec chmod 644 {} \;
chmod +x scripts/*.sh

That sets sane defaults across the tree, then re-marks the actual scripts as executable. The full reference for find, xargs, and the rest of the toolchain I lean on lives in the bash cheatsheet.

Symbolic Mode: Sometimes Friendlier

Octal is great when you know the exact end state. Symbolic mode is great when you want a relative change:

• chmod +x deploy.sh — add execute for everyone.
• chmod u+w,go-w report.txt — give the owner write, take it away from group and others.
• chmod -R a-w archive/ — recursively strip write from everybody.

I use symbolic mode in shell history when I'm not yet sure what the file currently is. I use octal in scripts where I want to assert the exact final state regardless of what was there.

The Security Mistakes That Matter

A few categories of mistake show up repeatedly in postmortems:

777 on a web directory. This was the cause of my own compromise. World-writable means anyone with shell access — or a web process that gets tricked into writing a file — can drop a PHP backdoor in your docroot. Never use 777. If something "only works at 777," the bug is elsewhere (usually owner mismatch).

666 on a config file with credentials. World-readable database credentials are a real category of bug. .env files should be 600 (rw owner only) or 640 (owner + group). Same applies to SSH private keys, which ssh will outright refuse to use if they're group- or world-readable.

Removing execute from /home. If you chmod 600 /home/yourname, your web server (or any cron job running as you) can no longer reach files inside, because it lost the directory-entry bit. Permissions on parent directories cascade in surprising ways.

The setuid Trap

There's a fourth permission bit ahead of the three trios — the "special" bit — written as a leading digit: 4755, 2755, 1755. The 4 means setuid: when you execute the file, the kernel runs it with the file owner's privileges, not yours.

This is how passwd works. The file is owned by root and is setuid; when a normal user runs it, it briefly becomes root to write /etc/shadow, then drops back down.

It is also how a careless script becomes a privilege-escalation vulnerability. The rule I follow: never setuid a script. Setuid on a shell script is ignored on modern Linux (for good reasons), and on the older systems where it works, it's a known exploit vector. Setuid on a compiled binary you wrote is sometimes the right answer, but only if you have audited every input.

If you see -rwsr-xr-x (note the s instead of x in the owner position) on a file you didn't expect, ask why before you ignore it.

A Quick Reference

| Permission | Octal | What it's for | |------------|-------|---------------| | rwxr-xr-x | 755 | Directories, executables | | rw-r--r-- | 644 | Regular files (configs, docs, images, CSS, HTML) | | rw------- | 600 | Secrets (.env, SSH private keys, credentials) | | rwxr-x--- | 750 | Directories where group can read, others can't | | rw-rw-r-- | 664 | Shared editable files inside a team group | | --------- | 000 | "Don't touch this" sentinel |

If you find yourself reaching for vim to inspect a script's behavior before running it, the patterns are documented in the vim cheatsheet. And for the surrounding web-server config that's usually the next thing to debug after a permissions issue, the nginx cheatsheet has the directives I check first.

TL;DR

755 for things you enter or run. 644 for things you read. 600 for secrets. Never 777. Setuid only on audited binaries, never on scripts. That covers about 95% of the chmod calls you'll ever make.

Related tools

• awk + sed Cheatsheet
• curl Cheatsheet

Made by Toolora · Updated 2026-05-26

Cron is one of those tools where the syntax looks like line noise for about 20 minutes, then becomes second nature, and then you forget that other people don't read */5 1-5 * * 1-5 as fluently as English. This post is the bridge from line noise to fluent — five fields, 15 patterns I actually use, and three gotchas that have woken me up.

If you want to verify expressions as you read, the cron expression explainer translates any line into plain English in real time.

The Five Fields

A standard cron line has five space-separated fields, plus the command:

┌─────────── minute       (0–59)
│ ┌───────── hour         (0–23)
│ │ ┌─────── day of month (1–31)
│ │ │ ┌───── month        (1–12 or JAN–DEC)
│ │ │ │ ┌─── day of week  (0–6, 0 = Sunday, or SUN–SAT)
│ │ │ │ │
* * * * *  command

Each field accepts:

• * — every value.
• A single number — exactly that value.
• A list like 1,3,5 — any of these.
• A range like 9-17 — inclusive both ends.
• A step like */15 — every 15. Combine with ranges: 0-30/5 is 0, 5, 10, 15, 20, 25, 30.

Two important quirks before the examples:

• Day-of-month and day-of-week are OR, not AND. If both fields are restrictive (not *), the job runs when either matches. 0 12 13 * 5 runs at noon on the 13th and every Friday at noon. This catches everyone once.
• There is no "every other day" in standard cron. */2 in the day-of-month field means days 1, 3, 5, … 29, 31 — which gives you back-to-back runs across month boundaries. If you need true every-48-hours, use systemd timers or a wrapper script that checks a state file.

15 Crontab Patterns I Actually Use

# 1. Every minute (smoke tests, health-check pingers)
* * * * * /usr/local/bin/healthcheck.sh

# 2. Every 5 minutes
*/5 * * * * /usr/local/bin/queue-poller.sh

# 3. Every 15 minutes during business hours, weekdays only
*/15 9-17 * * 1-5 /usr/local/bin/sales-sync.sh

# 4. Every hour at the top of the hour
0 * * * * /usr/local/bin/hourly-rollup.sh

# 5. Every hour at :17 (offset to dodge thundering herd)
17 * * * * /usr/local/bin/cache-warm.sh

# 6. Every 6 hours
0 */6 * * * /usr/local/bin/cleanup-temp.sh

# 7. 03:00 every day (nightly batch)
0 3 * * * /usr/local/bin/nightly-report.sh

# 8. 03:00 every weekday, skip weekends
0 3 * * 1-5 /usr/local/bin/business-day-only.sh

# 9. 09:00 every Monday
0 9 * * 1 /usr/local/bin/weekly-digest.sh

# 10. 00:00 on the 1st of every month
0 0 1 * * /usr/local/bin/monthly-invoice.sh

# 11. 00:00 on the last day of the month (with the LAST hack)
55 23 28-31 * * [ "$(date -d tomorrow +\%d)" = "01" ] && /usr/local/bin/month-end.sh

# 12. Every quarter (Jan, Apr, Jul, Oct on the 1st at 02:00)
0 2 1 1,4,7,10 * /usr/local/bin/quarterly.sh

# 13. Twice a day — 06:00 and 18:00
0 6,18 * * * /usr/local/bin/twice-daily.sh

# 14. @reboot — run once when the machine comes up
@reboot /usr/local/bin/start-tunnel.sh

# 15. Every 2 minutes, but only between 02:00 and 04:00 (low-traffic window)
*/2 2-3 * * * /usr/local/bin/heavy-job.sh

Pattern 11 — "last day of the month" — is the one I have to look up every time, because vanilla cron has no day-of-month "last." The trick is to run every day from the 28th to the 31st, then have the command itself check whether tomorrow is the 1st. Ugly, but reliable on every cron implementation.

If you'd rather not hand-craft these, the crontab helper is a visual builder — pick frequency, pick range, get the line. I still keep these 15 as a paste-bin because typing is faster than clicking once you know what you want.

The Three Gotchas

Gotcha 1: Daylight Saving Time

Most cron implementations run in local time. On the "spring forward" night when 02:00 jumps to 03:00, a job scheduled for 0 2 * * * will not run that day. On the "fall back" night when 02:00 happens twice, the same job will run twice.

Fixes, in order of preference:

1. Schedule batch jobs at 03:00 or later. The DST jumps in most jurisdictions are around 02:00–03:00; staying above that window dodges both.
2. Run cron in UTC. Set CRON_TZ=UTC at the top of the crontab (works on Vixie cron and successors). The job then sees no DST at all.
3. Use systemd timers, which have explicit OnCalendar= semantics around DST.

I learned this when a monthly billing report skipped one March. Took two cycles to notice. Now everything financial runs at 04:00 UTC and never moves.

Gotcha 2: PATH and Environment

A cron job runs with a minimal environment — typically just HOME, LOGNAME, PATH=/usr/bin:/bin, and SHELL=/bin/sh. Your ~/.bashrc is not sourced. Your nvm setup is not loaded. Your custom binaries in /usr/local/bin may or may not be on PATH depending on the cron daemon.

Symptoms: works fine when you run it from the shell, silently does nothing from cron. The fix is one of:

• Use absolute paths for every binary in the command.
• Set PATH= explicitly at the top of the crontab.
• Have the cron line call a wrapper script whose first line is source /home/you/.bashrc or whatever bootstrap you need.

The kind of one-liners that look fine in your terminal but die in cron usually involve awk, sed, find, or xargs invoked without full paths. The awk/sed cheatsheet is what I keep open when debugging these — the syntax is exact in a way that interactive shell forgiveness hides.

Gotcha 3: The Missing Newline

A crontab file must end with a newline. Some cron daemons silently ignore the last line if it doesn't have one. The symptom is "my new job isn't running and the other jobs are fine." I've lost an embarrassing hour to this one.

Fix: always edit with crontab -e (which appends a newline for you if missing) instead of piping in with crontab < file. If you must pipe, end the file with a literal blank line.

Related: the file needs to be readable by the cron daemon and the user running it, the user must be in /etc/cron.allow if that file exists, and SELinux on RHEL-family distros may block scripts in unusual locations. Standard bash debugging patterns apply — start with 2>&1 | logger -t myjob on the command and watch /var/log/syslog (or journalctl -t myjob) while it runs.

A Final Tip: Always Log Output

The single best thing you can do for future-you is redirect every cron job's output somewhere you can read later. Cron will email it to the local user mailbox by default, which on most servers nobody reads. Better:

0 3 * * * /usr/local/bin/nightly-report.sh >> /var/log/nightly-report.log 2>&1

Three months from now when you're debugging why the report stopped, having a log file makes the difference between "two-minute fix" and "two-hour archaeology."

Related tools

• Next.js Cheatsheet
• Python Cheatsheet

Made by Toolora · Updated 2026-05-26

I keep a JSON formatter pinned in a browser tab the way other people keep a calculator on their dock. Roughly 12 times a week, I paste something messy in, get something readable out, and move on with my day. Below are the five scenarios that account for almost all of those 12 times — and a quick note on when "beautify" and "minify" are actually different jobs, not the same button with different names.

If you want to follow along, the tool I'm using is json-formatter. Runs entirely in your tab. Your payload never leaves the browser.

Beautifier vs Minifier: Not the Same Tool

A JSON beautifier adds whitespace so a human can read the structure. A JSON minifier strips whitespace so a machine can transfer it faster.

A 240 KB API response I pulled last Tuesday went from 240 KB to 178 KB after minify — about 26% smaller, which on a 3G connection is a noticeable hitch saved. The reverse direction (beautify) doesn't change semantics at all; it just changes whether you can scan the file in five seconds or five minutes.

Rule of thumb I follow: beautify when a human is the next reader, minify when a network is.

Scenario 1: Debugging an API Response at 11 pm

A staging endpoint returns 400 with a single-line body 4,000 characters long. Chrome's preview pane crops it. console.log wraps it into noodle soup.

I copy the body, paste into the formatter, hit beautify, and the actual issue — a missing currency field nested 4 levels deep inside lineItems[2].pricing — becomes visible in about 8 seconds. Doing the same thing with jq from a terminal is also fine, but only if you remember the jq syntax for "show me everything" (jq '.') and have already piped the body to a file.

Scenario 2: Diffing Two Configs

config.staging.json and config.prod.json should differ in three keys. They differ in eleven. Until both files are formatted identically (same indentation, same key order if you sort), a line-based diff is useless.

Workflow:

1. Paste staging config, beautify, copy.
2. Paste prod config, beautify, copy.
3. Drop both into a text diff or your editor's diff view.

You go from "they're totally different, who knows" to "lines 14, 27, 41" in under a minute.

Scenario 3: Extracting One Value from a 5 MB Payload

A logging service exports a 5 MB JSON blob and you only need the userId of every event with status: "failed". The naive workflow is: open in IDE, wait for the syntax highlighter to catch up, Ctrl-F, copy each hit. Painful.

Better: beautify in the formatter (it handles 5 MB in well under a second client-side), use the browser's find-in-page to count occurrences, then if you actually need to extract programmatically, run a tiny snippet in DevTools console. The formatter just makes the structure scannable enough that you know what to grep for.

Scenario 4: Redacting Before You Paste in Slack

You want to share a JSON payload with a teammate. It contains an email, a token, and an internal customer ID. You can't paste it as-is.

Beautify first so you can see the structure. Then it's two minutes of manual redaction with sane indentation, instead of ten minutes of "wait, was that the third or fourth id field." The beautified version makes the redaction obvious; the minified version hides fields inside walls of commas.

Related neighbor formats I hit the same week: yaml-formatter for k8s manifests, xml-formatter for the one SOAP service that refuses to die, and csv-to-json when a "data export" turns out to be a CSV someone needs in JSON shape.

Scenario 5: Validating Before You Commit

The fastest way to know whether a hand-edited JSON file is valid is to paste it into a formatter. If beautify works, the file parses. If it errors, you get a line number and column.

I've caught the following in the last month, all in under five seconds each:

• Trailing comma after the last array element (JSON doesn't allow this; many editors don't flag it).
• Single quotes where double quotes were required (you wrote it in a JS object habit).
• An unescaped backslash inside a Windows path string.
• A literal NaN where a number was expected (NaN is not valid JSON; only finite numbers are).

Each of those would have produced a confusing error somewhere downstream — a CI failure, a 500 in prod, a parsing bug in a frontend bundle. Catching them at the formatter step costs nothing.

When the Formatter Isn't Enough

A few cases where I go beyond a beautifier:

• Schema validation: if you need to enforce types and required fields, a formatter won't catch a missing field; you need a JSON Schema validator.
• Repeated transforms: if you're doing the same extraction 50 times, write a jq one-liner once.
• Streaming JSON / NDJSON: a beautifier expects a single document. For line-delimited JSON, split first, then format each line.

For everything else — the 12 times a week kind of work — paste, beautify, scan, done.

Made by Toolora · Updated 2026-05-26