Ignored lines: {{ invalidWordsPreview }}
| Word | Placement | Length | Copy |
|---|---|---|---|
| {{ row.word }} | {{ row.placed ? 'Placed' : 'Skipped' }} | {{ row.length }} |
No words to show yet. Generate a puzzle first.
Word search puzzles hide target words inside a square grid of letters and ask the solver to scan along straight lines until each listed word appears. They are easy to explain, quick to print, and flexible enough for classroom vocabulary sheets, party games, travel activities, and themed practice packs.
This generator builds that grid from your own list rather than from a canned puzzle bank. You can set the puzzle title, choose the grid size, decide whether diagonal or backward placements are allowed, keep a seed for repeatable layouts, and then review the puzzle, answer key, summary metrics, word-status table, and JSON snapshot produced from the same run.
That makes it useful when the words themselves matter more than a generic difficulty label. A teacher can turn lesson vocabulary into a printable activity, a parent can build a themed sheet around familiar names, and an event host can create a custom table activity that feels specific to the group instead of purchased off the shelf.
The summary badges are there to show quality rather than decoration. The counts for placed words, skipped words, invalid lines, and fill percentage tell you whether the list actually fit the chosen grid and how much of the finished puzzle is occupied by target letters instead of filler.
The main boundary is that this is a layout generator, not a solver or formal difficulty grader. It accepts only A to Z lines, it does not treat spaces or punctuation as part of a word, and its diagonal handling is narrower than the eight-direction style some printed word searches use. The answer key and Word details tab are the reliable proof of what really made it into the puzzle.
Start by pasting the raw list exactly as you have it, then generate once before worrying about polish. The text under Word list immediately tells you how many entries are valid and how many will be ignored, which is the quickest way to catch spaces, punctuation, or accented text that this package does not place.
For a dependable first pass, keep the puzzle generous. If you are not sure how well the list will fit, begin with a larger Grid size, leave diagonals enabled, and only tighten the puzzle after you know the words place cleanly. The summary block and Word details table tell you much more than the finished grid alone, because a nice-looking puzzle can still hide skipped or ignored entries.
Grid size or shorten the entry before generating again.Fill percentage means more cells belong to target words, not automatically that the puzzle is harder. Direction choices often change solve difficulty more than density alone.Seed only when you want the same layout again. Changing the word list, grid size, or direction switches changes the result even if the seed text stays the same.Before exporting or sharing, open Answer key and Word details once. If every intended word is marked Placed and no unexpected invalid or skipped counts remain, the puzzle is usually ready to hand out.
Generation begins with line cleanup rather than with the grid. Each non-empty line is trimmed, converted to uppercase, and tested against an A to Z pattern. Valid lines stay in the working list exactly as entered, which means repeated valid words can be attempted more than once. Invalid lines are excluded from placement and recorded separately for the warning block and JSON diagnostics.
Placement is then driven by a bounded search. Words are sorted from longest to shortest so the harder placements get first access to the grid. For each word the package chooses a direction and start cell from a seeded pseudo-random stream, tests whether the word stays inside the grid, and allows overlaps only when existing letters already match the incoming letters. Each word gets up to 500 placement attempts before it is marked as skipped.
The allowed directions are intentionally narrower than some print-puzzle conventions. The base set is left-to-right and top-to-bottom. Turning on diagonals adds the main downward diagonal only. Turning on backwards adds the reverse horizontal and vertical directions and, when diagonals are already enabled, the reverse of that same diagonal. The package does not add the opposite diagonal family, so this generator does not explore all eight compass directions.
After placement, the remaining cells are filled with random capital letters and the occupied-cell ratio is summarized as:
| Symbol or field | Meaning | Type | Package surface |
|---|---|---|---|
N |
Grid size per side | integer | Grid size |
A |
Cells that belong to placed words | integer | Fill percentage |
Placed words |
Count of words that found legal positions | integer | Summary badge and summary tab |
Skipped words |
Words that were valid but never placed | integer | Summary badge, alert, JSON diagnostics |
Invalid entries |
Lines rejected before placement | integer | Summary tab and warning alert |
answerMask |
Boolean map of which cells belong to placed words | grid | Answer key and JSON output |
| Rule or field | Package behavior | What it means in practice |
|---|---|---|
Word list |
Only lines matching A-Z after trimming and uppercasing are valid |
Spaces, punctuation, numbers, and accented forms are ignored unless you rewrite them |
Grid size |
Clamped to 5 through 25 | Short grids can reject long words before any placement attempts begin |
| Direction set | Right, down, optional main diagonal, and reverse variants | The opposite diagonal family is never used in this package |
| Placement attempts | Maximum 500 tries per word | A word can be skipped even when it is shorter than the grid if conflicts never clear |
Word details |
Collapses repeated text to one status row | Repeated valid words may be attempted multiple times even though the table shows one row per unique spelling |
The pseudo-random stream behind the layout is deterministic when a seed is supplied. The package converts the seed text into a numeric starting state by summing character codes and then steps through a multiplicative congruential generator. That is why the same valid word list, grid size, direction options, and seed reproduce the same puzzle, while any change to those inputs leads to a different letter arrangement.
Puzzle generation, answer-key rendering, and file creation remain local to the current session. The package has no tool-specific backend path for processing word lists. That local behavior is useful for privacy, but it also means the quality of the finished puzzle depends entirely on the input list and the generated status cues shown in the page.
Use this sequence when you want a reliable puzzle rather than a quick experiment.
Puzzle title if the sheet needs a heading, then paste the source words into Word list, one entry per line. Watch the note below the box so you know how many lines are valid before you generate anything.Advanced and set Grid size, Seed, Allow diagonals, and Allow backwards. If you are unsure, choose a slightly larger grid and keep diagonals on for the first pass.Generate puzzle. A successful run fills the summary card and opens the result tabs. You should now see counts for placed words, fill percentage, skipped words, invalid entries, and the active seed when one exists.Grid size before trying another layout.Word Search to inspect the puzzle visually and open Answer key to confirm the highlighted path for each placed word. If the answer key does not match your expectation, fix the list or the direction rules before exporting.Summary and Word details next. A complete run shows the intended words as Placed and keeps Skipped words at zero. Treat that table as the authoritative check, not the appearance of the grid alone.When the answer key looks correct and every intended word is marked Placed, the puzzle is ready to print or share.
The first numbers to trust are Placed words and Skipped words. A dense-looking grid is not enough if a target word never made it in. The answer key and Word details table are the real proof of coverage.
Fill percentage is a density measure, not a formal difficulty score. A puzzle can have a modest fill percentage and still be hard if diagonal or backward paths are active.Invalid entries means those lines were excluded before placement. The finished grid gives no visual sign that they were dropped, so check that count directly.Before handing the puzzle to other people, compare Word details with Answer key once so you know the placed list, skipped count, and highlighted solution path all agree.
Enter PYTHON, RUBY, JAVA, and SWIFT on separate lines, set Grid size to 10, keep diagonals and backwards enabled, and use the seed lesson1. The summary shows Placed words 4, Skipped words 0, Fill percentage 19.0%, and seed lesson1. In Word details, all four words are marked Placed, which makes this a clean print-ready run.
Enter CAT, DOG, and ELEPHANT, choose a Grid size of 5, keep diagonals enabled, turn backwards off, and use the seed animals. The result shows Placed words 2, Skipped words 1, and Fill percentage 24.0%. The alert identifies ELEPHANT as longer than the grid, so the fix is to enlarge the grid or shorten that entry, not to keep regenerating the same setup.
Enter RAIN, SUN, ICE-CREAM, and SNOW DAY with Grid size 8, diagonals and backwards enabled, and seed weather. The summary shows Placed words 2, Skipped words 0, Invalid entries 2, and Fill percentage 10.9%. Rewriting the rejected lines as ICECREAM and SNOWDAY makes them eligible on the next run.
Only lines made of letters A to Z survive validation. Spaces, hyphens, punctuation, numbers, and accented forms are recorded as invalid and skipped before placement begins.
Length is only the first test. The package still has to find a legal path that stays inside the grid and does not conflict with letters already placed. Each word gets up to 500 tries before it is marked as skipped.
Yes, if the valid word list, Grid size, Allow diagonals, and Allow backwards settings stay the same. Change any of those and the letter layout changes too.
Word details show only one row for a repeated word?That table collapses identical spellings into one status row for readability. Repeated valid words can still be attempted more than once during generation even though the status table shows one row per unique spelling.
No tool-specific backend is present for puzzle generation. Layout, answer masking, and file creation happen in the current session.