Puzzle overview
{{ placedWordCount }} placed {{ fillPercent }}% filled {{ skippedWordCount }} skipped {{ invalidWords.length }} invalid
Seed: {{ seedDisplay }}
{{ wordCountLabel }}
{{ gridSize }} × {{ gridSize }}
{{ cellSize }} px
{{ exportScaleDisplay }}
{{ pdfMarginDisplay }}
  • {{ w }}
  • {{ w }} found
Placed words
{{ placedWordCount }}
Fill percentage
{{ fillPercent }}%
Skipped words
{{ skippedWordCount }}
Invalid entries
{{ invalidWords.length }}
Seed
{{ seedDisplay }}

Ignored lines: {{ invalidWordsPreview }}

Word Placement Length Copy
{{ row.word }} {{ row.placed ? 'Placed' : 'Skipped' }} {{ row.length }}

No words to show yet. Generate a puzzle first.


                        
:

Introduction:

Word search puzzles are letter grids that hide target words along straight lines, and they reward careful scanning and pattern recognition. They are used for quick brain breaks, warm ups in classrooms, and casual challenges with family or friends.

You provide a short list of words and pick simple layout rules, and a neatly packed grid is built for you to print or share. The summary shows how many words landed and how much of the grid those words occupy so you can judge difficulty at a glance.

Reproducible layouts help when you want the same puzzle for several groups, so a seed lets you recreate a prior grid with the same list. You can also reveal the answers for checking and then switch them off again before saving.

For best results use plain letters without spaces and keep very long words for larger grids. Short streaks of letters can appear by chance, so remind solvers to read the whole line before circling a find.

Technical Details:

The generator arranges uppercase words on a square grid and then fills empty cells with uniformly random letters. A deterministic seed turns the layout into a repeatable sequence for the same inputs.

Words are placed on straight lines. Allowed directions always include right and down. Diagonals follow the main diagonal direction from top left to bottom right, and the backwards option adds the reverse direction up left. Intersections are permitted when letters match.

Difficulty is summarized by the proportion of grid cells that belong to placed words. A higher proportion means denser targets and usually a quicker solve; a lower proportion means more distraction from filler letters.

fillPercent = A N2 · 100
Symbols and units
Symbol Meaning Unit/Datatype Source
N Grid size per side integer Input
A Count of cells that belong to placed words integer Derived
r,c Row and column indices starting at zero integer Derived
dr,dc Direction steps per letter integer Constant set
Worked example. For N = 10 and A = 34:
fillPercent = 34100 · 100 = 34.0 %
Rounded to one decimal place.

Placement pipeline:

  1. Coerce grid size to an integer within 5–25.
  2. Normalize input to uppercase and keep lines of A–Z only.
  3. Sort words by length descending to place longer words first.
  4. Build allowed directions: right, down, optional main diagonal, and reverse when enabled.
  5. For each word, try up to 500 random start positions and directions.
  6. Accept a position when boundaries hold and overlaps match existing letters.
  7. After all words, fill remaining cells with random letters A–Z.
  8. Compute the filled proportion and show the word list.

Randomness & reproducibility:

A multiplicative congruential generator computes a repeatable stream from the seed. The seed is the sum of character codes from the seed text with a minimal fallback when the sum is zero. The same word list, options, and seed reproduce the same grid.

Units, precision & rounding:

  • Fill percentage is rounded to one decimal using standard numeric rounding.
  • PDF export uses A4 portrait with 10 mm margins; PNG export uses the rendered pixel size.
  • Cell size slider steps in 2 px increments for consistent scaling.

Validation & bounds extracted from code:

Validation rules and bounds
Field Type Min Max Step/Pattern Error Text Placeholder
Grid size number 5 25 integer coerced into range
Word list multiline text only A–Z lines kept invalid lines ignored Enter one word per line
Cell size slider 24 px 48 px step 2 px
Diagonals toggle main diagonal only
Backwards toggle adds reverse directions
Seed text repeatable layouts defaults internally if empty optional
Theme select classic, midnight, bubblegum, greyscale, forest, sunset, ocean
Title text slugged to safe filename Puzzle title

I/O formats:

Inputs and outputs
Input Accepted Families Output Encoding/Precision Rounding
Word list ASCII letters A–Z per line Puzzle grid and word list screen render
Options numbers, toggles, text seed PDF download A4 portrait, 10 mm margin
Options numbers, toggles, text seed PNG download canvas raster

Networking & storage behavior:

  • Puzzle generation and file creation run entirely on the client.
  • No server calls are made for inputs, layout, or downloads.
  • No data is transmitted or stored server‑side.

Performance & complexity:

  • Placement attempts are bounded to 500 per word.
  • Expected runtime grows with words, grid size, and word length.
  • Letter fill is linear in grid cells.

Diagnostics & determinism:

  • Identical inputs and seed yield identical grids.
  • Summary shows placed word count and filled percentage.
  • Answer view highlights placed letters for quick checking.

Security considerations:

  • Word lines are filtered to uppercase letters to prevent injection through markup.
  • Filenames are slugged to alphanumeric with underscores.
  • Downloads are initiated directly without server intermediaries.

Assumptions & limitations:

  • Only the main diagonal is supported for diagonals.
  • Overlaps require matching letters; crossings otherwise fail.
  • Very long words may not place within the attempt limit.
  • Only A–Z letters are accepted; accented characters are ignored.
  • Grid size is clipped to 5–25 even if an out‑of‑range number is entered.
  • Cell size affects display and exports but not logic.
  • Seeds based on character sums can collide for different texts.
  • Random filler letters can incidentally form misleading substrings.
  • Theme colors affect contrast; ensure readability when printing.
  • Mobile layouts may scale the grid for small screens.

Edge cases & error sources:

  • Blank lines or lines with spaces are dropped.
  • Numbers or punctuation in words cause those lines to be ignored.
  • Duplicate words may both place or compete for space.
  • Rounding of grid size can change placement with borderline values.
  • Seed empty string falls back internally to a minimal nonzero state.
  • Near‑full grids can starve shorter words of valid slots.
  • Printing with dark themes may reduce letter contrast.
  • Canvas rasterization can soften small text if scaled.
  • Rapid option changes between exports can toggle answer state mid‑save.
  • Extremely small cell sizes make on‑screen selection difficult.
  • Word order is resorted by length, which affects outcomes.
  • Browser zoom alters apparent pixel density in PNG exports.

Privacy & compliance: Processing is client‑only. No personal data is transmitted or stored server‑side. Outcomes are purely random and have no monetary value.

How‑to · Build a puzzle:

Word search generation starts with the concept of hidden words in a grid and ends with a printable puzzle and optional answer key.

  1. Enter one word per line using A–Z letters only.
  2. Choose grid size and cell size to fit your word lengths.
  3. Pick diagonals and backwards if you want added challenge.
  4. Set a seed for a repeatable layout or leave it blank for variety.
  5. Generate the grid, review the summary, and adjust if needed.
  6. Reveal answers if desired, then export to PDF or PNG.

Example. Ten to twelve medium‑length words usually fit well on a 12×12 grid with diagonals enabled and backwards off.

  • Tip: Keep themes high‑contrast for classroom projectors and photocopies.
  • Tip: Use a seed to distribute the same puzzle to several groups.

FAQ:

Is my data stored?

No. Generation and exports run on your device and no inputs are sent to a server.

How accurate is the summary?

It counts placed‑letter cells and divides by total cells, then rounds to one decimal. It is exact for the shown grid.

Which inputs are valid?

Use uppercase letters A–Z without spaces or punctuation. Lines with other characters are ignored to keep the grid clean.

Does it work without a connection?

Yes. After the page is loaded, puzzle building and file downloads do not require network access.

What does it cost?

No payments or keys are requested by the interface. Licensing or redistribution terms are not specified here.

How do I get the same layout again?

Enter the same words, options, and the same seed. The layout will match exactly.

What does “filled” actually mean?

“Filled” refers to cells that belong to placed words, not all letters shown. Filler letters are excluded from the percentage.

Can I force diagonal in both directions?

Diagonal placement follows the main diagonal. Enabling backwards adds the reverse direction for that diagonal.

Troubleshooting:

  • No words appear — check that each line contains only letters A–Z.
  • Long words fail — increase the grid size or switch off backwards.
  • Words overlap incorrectly — ensure overlaps share the same letter.
  • Export looks soft — increase cell size before saving PNG.
  • Dark printouts — switch to a lighter theme before exporting.
  • Layout changes unexpectedly — confirm the seed is unchanged.