Freeform Strategy

Longest First

Places longer words first as anchors, then fits shorter words around them.

The classic crossword construction approach: long words become the structural backbone of the grid, and shorter words fill in around them.

Long words have more letters, which means more potential crossing points. By placing them first, every subsequent shorter word has a wider variety of intersection options to choose from.

This strategy tends to produce grids shaped around one or two long anchor words. In benchmarks, it often yields favorable compactness ratios (grid area per placed word) since long anchors define a tight bounding box that shorter words pack into. However, it may place fewer total words than connectivity-aware strategies because word ordering ignores the compatibility graph.

Strengths

  • Long words are guaranteed to be placed (since they go first, they always succeed)
  • Produces among the most compact grids per placed word, and the fastest execution time of any strategy (no graph computation)
  • Simple and predictable: word length alone determines ordering, making results easy to reason about

Weaknesses

  • !Does not account for word compatibility, so long words might be placed where they offer few crossing opportunities for shorter words
  • !Can leave more words unplaced than graph-aware strategies, since ordering by length ignores connectivity

How It Works

  1. 1

    Sort words by length descending

    Word lengths from longest to shortest. Among words of equal length, the order is randomized across attempts to produce different layouts.

  2. 2

    Place words greedily in order

    Place the longest word horizontally at origin. For each subsequent word, find the placement that maximizes intersections with already-placed words. Long words placed early give later words more options.

Pseudocode

function longestFirstOrder(words):
    return sort(words, by length descending,
                ties broken randomly per attempt)

function placeWords(orderedWords):
    place orderedWords[0] horizontally at (0, 0)
    for word in orderedWords[1:]:
        bestPlacement = null
        for placedWord in placed:
            for sharedLetter in word ∩ placedWord:
                p = perpendicularPlacement(word, placedWord, sharedLetter)
                if isValid(p):
                    score = countIntersections(p)
                    if score > bestScore:
                        bestPlacement = p
        if bestPlacement:
            place(word, bestPlacement)

Complexity

Sort: O(W log W). Placement: O(W² × L²) for the greedy search. Total: O(W² × L²) per attempt.

Benchmark Results

Measured locally on three wordlist scenarios. Each cell is averaged across 3 runs of 16 attempts each. Best= top layout's metric. Compactness = grid area per placed word (lower is denser).

ScenarioBest ×Avg ×PlacedCompactnessTime
Themed (9 words)
Short personal wordlist with low letter overlap, typical of user input.
889/98.561.2ms
Vocabulary (40 words)
Common 5-letter English words with high letter overlap.
4240.2540/4015.9514.8ms
Mixed (156 words)
Mixed-length English words (3–8 letters), broad coverage.
158153.25151/15610.3378.6ms

★ Best across all four strategies on this scenario. Reproducible via scripts/benchmark-strategies.ts.

Metric Definitions

Each benchmark run executes 16 randomized attempts of the strategy and returns up to 4 distinct layouts, sorted by quality. This process is repeated 3 times to reduce variance. The metrics below describe how each column is derived from those runs.

Best ×
The highest intersection count from the top-ranked layout across 3 independent runs. An intersection is a grid cell shared by two words (one across, one down). Higher is better.
Avg ×
The mean intersection count across all returned layouts (up to 4 per run), averaged over 3 runs. This includes second- through fourth-best layouts, so it reflects consistency rather than peak performance.
Placed
The most words placed on the grid in any top-ranked layout. For Adjacency-Aware, this includes dictionary fill words from Phase 2, so it can exceed the input word count. Shown as placed/input.
Compactness
Grid bounding-box area (rows times columns) divided by the number of placed words. Lower values indicate denser packing. Note that this measures the full bounding box, which includes empty cells between words. Adjacency-Aware's denominator is inflated by fill words.
2-Letter Frags
The number of 2-letter contiguous letter runs in the best grid that are not covered by any placed word in that direction. These are perpendicular fragments left behind by parallel placements that Phase 2 could not extend into complete dictionary words. Only applicable to adjacency strategies; always 0 for other strategies since they never place words in parallel.
Fill Words
The number of dictionary words added in Phase 2 to extend 2-letter gaps into complete words. These are not from the user's word list. Capped at max(3, 75% of user word count). Only applicable to adjacency strategies.
Time
Wall-clock time for one run (16 randomized attempts), averaged across 3 runs. Measured in single-threaded JavaScript without Web Workers. Includes ordering, candidate enumeration, validation, and (for Adjacency-Aware) Phase 2 gap filling.

Comparative Performance

All four strategies measured side-by-side on the same word lists and hardware. Rows highlighted in blue indicate the strategy being viewed.

Themed (9 words)Short personal wordlist with low letter overlap, typical of user input.

StrategyBest ×Avg ×PlacedCompactFragsFillTime
Adjacency-Aware161512/9603125.9ms
Parallel-Seeded2018.7514/9525128.8ms
Densest Crossings98.259/911.56001.3ms
Longest First889/98.56001.2ms
Balanced98.259/915.89001.4ms

Vocabulary (40 words)Common 5-letter English words with high letter overlap.

StrategyBest ×Avg ×PlacedCompactFragsFillTime
Adjacency-Aware9990.2569/407.711029781.9ms
Parallel-Seeded9693.568/4011.031128901.6ms
Densest Crossings4140.540/4019.20017.6ms
Longest First4240.2540/4015.950014.8ms
Balanced4140.540/4015.60019.6ms

Mixed (156 words)Mixed-length English words (3–8 letters), broad coverage.

StrategyBest ×Avg ×PlacedCompactFragsFillTime
Adjacency-Aware312300.5228/1567.0135725129.8ms
Parallel-Seeded306292.75228/1568.624725230.4ms
Densest Crossings157156.25153/1561000317.6ms
Longest First158153.25151/15610.330078.6ms
Balanced161157.25156/15612.3800306.8ms

Analysis

The four strategies share the same underlying greedy placement algorithm but differ in word ordering and, in the case of Adjacency-Aware, in which placements are considered valid. This means performance differences stem from two factors: the cost of computing the ordering, and the size of the candidate set evaluated per word.

Graph-guided, Balanced, and Longest First operate exclusively on the user's word list. Their placement pass considers only perpendicular intersection candidates (positions where a new word crosses an existing word at a shared letter). Longest First skips the graph-build step entirely, making it the fastest strategy in every scenario. Graph-guided and Balanced are similar in cost because they both compute the compatibility graph; Balanced adds a minor constant factor for its hybrid seed selection.

Adjacency-Aware adds two sources of overhead. First, each word's candidate set is larger because parallel placements (same direction, offset by one row or column) are enumerated alongside perpendicular intersections. For a word of length L placed beside an existing word of length P, this adds up to 2 × (L + P - 1) additional candidates per pair. Second, every candidate undergoes perpendicular-run validation against the dictionary, which requires walking the grid in the perpendicular direction at each cell. Phase 2 (gap filling) adds a third cost: scanning for 2-letter fragments and searching dictionary buckets for valid extensions.

The practical impact scales with word count. On a 9-word themed list, the adjacency strategies run in roughly 126-129ms versus 1.2ms for Longest First (approximately 100x slower). On 156 words, the gap narrows to roughly 65x (5.1-5.2s versus 79ms). The overhead comes from dictionary validation of perpendicular runs, parallel candidate enumeration, and gap filling.

An important caveat applies when comparing intersection counts across strategy types. The adjacency strategies' reported intersections include crossings involving dictionary fill words. For the mixed-large scenario, Adjacency-Aware places 228 total words (156 user + 72 fill) and reports 312 intersections, while Densest Crossings places 153 user words and reports 157 intersections. Some portion of the intersection difference is attributable to the additional fill words, not to more efficient placement of the original word list.

The 2-letter fragment count reveals an inherent tradeoff of parallel placement. Every pair of words placed side-by-side creates perpendicular 2-letter runs that must either be extended into dictionary words or left as fragments. Inline gap filling (used by both adjacency strategies) mitigates this by resolving gaps immediately after each parallel placement, while surrounding constraints are still loose. Parallel-Seeded reduces fragments by roughly 43% compared to deferred filling on large word lists, producing 24 fragments versus 35 for base Adjacency-Aware on the mixed-large scenario. The remaining fragments are structurally unfillable due to constraints accumulated during grid construction.

The compactness metric (grid area divided by placed words) also requires careful interpretation. Adjacency-Aware tends to produce grids with lower compactness values, which suggests denser packing. However, the fill words extend existing perpendicular runs rather than expanding the grid boundary, so they reduce compactness partly by inflating the denominator without proportionally increasing the numerator. Among the user-word-only strategies, Longest First tends to produce the most compact grids, likely because long anchor words create a tighter bounding box relative to the words they accommodate.

Each strategy was run 3 times with 16 randomized attempts per run. Adjacency-aware loads the full crossword dictionary (~42K words, filtered to 3-8 letters with score >= 60) for perpendicular validation and gap filling; other strategies use only the scenario's word list. Note that adjacency-aware's "placed" count includes dictionary fill words from Phase 2, so its intersection counts are not directly comparable to other strategies, which only place words from the input list.

When to Use This

  • You have one or two long themed entries you want prominently displayed
  • Your word list has high length variance (mix of 3-letter and 8+ letter words)
  • You prefer a more traditional, anchor-driven crossword aesthetic

Try it

Open the creator with this strategy pre-selected.

Try Longest First

Other Strategies