diff --git a/config.json b/config.json
index cf854d48..ed915bae 100644
--- a/config.json
+++ b/config.json
@@ -1194,6 +1194,17 @@
           "loops"
         ]
       },
+      {
+        "slug": "word-search",
+        "name": "Word Search",
+        "uuid": "e88da49b-37d7-4f84-ad64-765fb464a721",
+        "practices": [],
+        "prerequisites": [],
+        "difficulty": 5,
+        "topics": [
+          "algorithms"
+        ]
+      },
       {
         "slug": "bowling",
         "name": "Bowling",
diff --git a/exercises/practice/word-search/.docs/instructions.md b/exercises/practice/word-search/.docs/instructions.md
new file mode 100644
index 00000000..e2d08aa9
--- /dev/null
+++ b/exercises/practice/word-search/.docs/instructions.md
@@ -0,0 +1,24 @@
+# Instructions
+
+In word search puzzles you get a square of letters and have to find specific words in them.
+
+For example:
+
+```text
+jefblpepre
+camdcimgtc
+oivokprjsm
+pbwasqroua
+rixilelhrs
+wolcqlirpc
+screeaumgr
+alxhpburyi
+jalaycalmp
+clojurermt
+```
+
+There are several programming languages hidden in the above square.
+
+Words can be hidden in all kinds of directions: left-to-right, right-to-left, vertical and diagonal.
+
+Given a puzzle and a list of words return the location of the first and last letter of each word.
diff --git a/exercises/practice/word-search/.meta/Sources/WordSearch/TrieNode.swift b/exercises/practice/word-search/.meta/Sources/WordSearch/TrieNode.swift
new file mode 100644
index 00000000..fc2deb0d
--- /dev/null
+++ b/exercises/practice/word-search/.meta/Sources/WordSearch/TrieNode.swift
@@ -0,0 +1,57 @@
+
+class TrieNode {
+    var children: [Character: TrieNode] = [:]
+    var word: String? = nil
+}
+
+extension TrieNode {
+
+    static func buildTrie(_ words: [String]) -> TrieNode {
+        let root = TrieNode()
+        for word in words {
+            var node = root
+            for char in word {
+                if node.children[char] == nil {
+                    node.children[char] = TrieNode()
+                }
+                node = node.children[char]!
+            }
+            node.word = word
+        }
+        return root
+    }
+
+    static func dfs(
+        board: [[Character]],
+        initialRow: Int,
+        initialColumn: Int,
+        row: Int,
+        column: Int,
+        direction: (Int, Int),
+        node: TrieNode,
+        result: inout [String: WordLocation?]
+    ) {
+        guard row >= 0, row < board.count, column >= 0, column < board[0].count else { return }
+
+        let char = board[row][column]
+        guard let nextNode = node.children[char] else { return }
+
+        if let word = nextNode.word {
+            let start = WordLocation.Location(row: initialRow + 1, column: initialColumn + 1)
+            let end = WordLocation.Location(row: row + 1, column: column + 1)
+            result[word] = WordLocation(start: start, end: end)
+        }
+
+        dfs(
+            board: board,
+            initialRow: initialRow,
+            initialColumn: initialColumn,
+            row: row + direction.0,
+            column: column + direction.1,
+            direction: direction,
+            node: nextNode,
+            result: &result
+        )
+    }
+
+}
diff --git a/exercises/practice/word-search/.meta/Sources/WordSearch/WordLocation.swift b/exercises/practice/word-search/.meta/Sources/WordSearch/WordLocation.swift
new file mode 100644
index 00000000..b7913365
--- /dev/null
+++ b/exercises/practice/word-search/.meta/Sources/WordSearch/WordLocation.swift
@@ -0,0 +1,12 @@
+
+struct WordLocation: Equatable {
+
+    struct Location: Equatable {
+        let row: Int
+        let column: Int
+    }
+
+    let start: Location
+    let end: Location 
+
+}
\ No newline at end of file
diff --git a/exercises/practice/word-search/.meta/Sources/WordSearch/WordSearchExample.swift b/exercises/practice/word-search/.meta/Sources/WordSearch/WordSearchExample.swift
new file mode 100644
index 00000000..f7280346
--- /dev/null
+++ b/exercises/practice/word-search/.meta/Sources/WordSearch/WordSearchExample.swift
@@ -0,0 +1,30 @@
+import Foundation
+
+func search(words: [String], in grid: [String]) -> [String: WordLocation?] {
+    let board: [[Character]] = grid.map { Array($0) }
+    let trie = TrieNode.buildTrie(words)
+    var result = [String: WordLocation?]()
+
+    let directions = [
+        (-1,0), (1,0), (0,-1), (0,1),
+        (-1,-1), (1,1), (1,-1), (-1,1)
+    ]
+    for row in 0..<board.count {
+        for column in 0..<board[0].count {
+            for direction in directions {
+                TrieNode.dfs(
+                    board: board,
+                    initialRow: row,
+                    initialColumn: column,
+                    row: row,
+                    column: column,
+                    direction: direction,
+                    node: trie,
+                    result: &result
+                )
+            }
+        }
+    }
+
+    return result
+}
diff --git a/exercises/practice/word-search/.meta/config.json b/exercises/practice/word-search/.meta/config.json
new file mode 100644
index 00000000..f7f4e0bf
--- /dev/null
+++ b/exercises/practice/word-search/.meta/config.json
@@ -0,0 +1,22 @@
+{
+  "authors": [
+    "Sencudra"
+  ],
+  "files": {
+    "solution": [
+      "Sources/WordSearch/WordSearch.swift"
+    ],
+    "test": [
+      "Tests/WordSearchTests/WordSearchTests.swift"
+    ],
+    "example": [
+      ".meta/Sources/WordSearch/WordSearchExample.swift",
+      ".meta/Sources/WordSearch/WordLocation.swift",
+      ".meta/Sources/WordSearch/TrieNode.swift"
+    ],
+    "editor": [
+      "Sources/WordSearch/WordLocation.swift"
+    ]
+  },
+  "blurb": "Create a program to solve a word search puzzle."
+}
diff --git a/exercises/practice/word-search/.meta/template.swift b/exercises/practice/word-search/.meta/template.swift
new file mode 100644
index 00000000..d9525da3
--- /dev/null
+++ b/exercises/practice/word-search/.meta/template.swift
@@ -0,0 +1,34 @@
+import Testing
+import Foundation
+@testable import {{exercise | camelCase}}
+
+let RUNALL = Bool(ProcessInfo.processInfo.environment["RUNALL", default: "false"]) ?? false
+
+@Suite struct {{exercise | camelCase}}Tests {
+    {% for case in cases %}
+        {% if forloop.first -%}
+            @Test("{{case.description}}")
+        {% else -%}
+            @Test("{{case.description}}", .enabled(if: RUNALL))
+        {% endif -%}
+        func test{{case.description | camelCase}}() {
+            let grid = {{case.input.grid | toStringArray}}
+            let words = {{case.input.wordsToSearchFor | toStringArray}}
+
+            var expected = [String: WordLocation?]()
+            {%- for word in case.expected %}
+                expected["{{word}}"] =
+                {%- if case.expected[word] | isNull -%}
+                    nil
+                {%- else -%}
+                    WordLocation(
+                        start: {{case.expected[word]["start"] | toStringDictionary}},
+                        end: {{case.expected[word]["end"] | toStringDictionary}}
+                    )
+                {%- endif %}
+            {%- endfor %}
+
+            #expect({{case.property}}(words: words, in: grid) == expected)
+        }
+    {% endfor -%}
+}
\ No newline at end of file
diff --git a/exercises/practice/word-search/.meta/tests.toml b/exercises/practice/word-search/.meta/tests.toml
new file mode 100644
index 00000000..3f98113d
--- /dev/null
+++ b/exercises/practice/word-search/.meta/tests.toml
@@ -0,0 +1,82 @@
+# This is an auto-generated file.
+#
+# Regenerating this file via `configlet sync` will:
+# - Recreate every `description` key/value pair
+# - Recreate every `reimplements` key/value pair, where they exist in problem-specifications
+# - Remove any `include = true` key/value pair (an omitted `include` key implies inclusion)
+# - Preserve any other key/value pair
+#
+# As user-added comments (using the # character) will be removed when this file
+# is regenerated, comments can be added via a `comment` key.
+
+[b4057815-0d01-41f0-9119-6a91f54b2a0a]
+description = "Should accept an initial game grid and a target search word"
+
+[6b22bcc5-6cbf-4674-931b-d2edbff73132]
+description = "Should locate one word written left to right"
+
+[ff462410-434b-442d-9bc3-3360c75f34a8]
+description = "Should locate the same word written left to right in a different position"
+
+[a02febae-6347-443e-b99c-ab0afb0b8fca]
+description = "Should locate a different left to right word"
+
+[e42e9987-6304-4e13-8232-fa07d5280130]
+description = "Should locate that different left to right word in a different position"
+
+[9bff3cee-49b9-4775-bdfb-d55b43a70b2f]
+description = "Should locate a left to right word in two line grid"
+
+[851a35fb-f499-4ec1-9581-395a87903a22]
+description = "Should locate a left to right word in three line grid"
+
+[2f3dcf84-ba7d-4b75-8b8d-a3672b32c035]
+description = "Should locate a left to right word in ten line grid"
+
+[006d4856-f365-4e84-a18c-7d129ce9eefb]
+description = "Should locate that left to right word in a different position in a ten line grid"
+
+[eff7ac9f-ff11-443e-9747-40850c12ab60]
+description = "Should locate a different left to right word in a ten line grid"
+
+[dea39f86-8c67-4164-8884-13bfc48bd13b]
+description = "Should locate multiple words"
+
+[29e6a6a5-f80c-48a6-8e68-05bbbe187a09]
+description = "Should locate a single word written right to left"
+
+[3cf34428-b43f-48b6-b332-ea0b8836011d]
+description = "Should locate multiple words written in different horizontal directions"
+
+[2c8cd344-a02f-464b-93b6-8bf1bd890003]
+description = "Should locate words written top to bottom"
+
+[9ee1e43d-e59d-4c32-9a5f-6a22d4a1550f]
+description = "Should locate words written bottom to top"
+
+[6a21a676-f59e-4238-8e88-9f81015afae9]
+description = "Should locate words written top left to bottom right"
+
+[c9125189-1861-4b0d-a14e-ba5dab29ca7c]
+description = "Should locate words written bottom right to top left"
+
+[b19e2149-7fc5-41ec-a8a9-9bc6c6c38c40]
+description = "Should locate words written bottom left to top right"
+
+[69e1d994-a6d7-4e24-9b5a-db76751c2ef8]
+description = "Should locate words written top right to bottom left"
+
+[695531db-69eb-463f-8bad-8de3bf5ef198]
+description = "Should fail to locate a word that is not in the puzzle"
+
+[fda5b937-6774-4a52-8f89-f64ed833b175]
+description = "Should fail to locate words that are not on horizontal, vertical, or diagonal lines"
+
+[5b6198eb-2847-4e2f-8efe-65045df16bd3]
+description = "Should not concatenate different lines to find a horizontal word"
+
+[eba44139-a34f-4a92-98e1-bd5f259e5769]
+description = "Should not wrap around horizontally to find a word"
+
+[cd1f0fa8-76af-4167-b105-935f78364dac]
+description = "Should not wrap around vertically to find a word"
diff --git a/exercises/practice/word-search/Package.swift b/exercises/practice/word-search/Package.swift
new file mode 100644
index 00000000..7072faa6
--- /dev/null
+++ b/exercises/practice/word-search/Package.swift
@@ -0,0 +1,21 @@
+// swift-tools-version:6.0
+
+import PackageDescription
+
+let package = Package(
+  name: "WordSearch",
+  products: [
+    .library(
+      name: "WordSearch",
+      targets: ["WordSearch"])
+  ],
+  dependencies: [],
+  targets: [
+    .target(
+      name: "WordSearch",
+      dependencies: []),
+    .testTarget(
+      name: "WordSearchTests",
+      dependencies: ["WordSearch"]),
+  ]
+)
diff --git a/exercises/practice/word-search/Sources/WordSearch/WordLocation.swift b/exercises/practice/word-search/Sources/WordSearch/WordLocation.swift
new file mode 100644
index 00000000..d3b32210
--- /dev/null
+++ b/exercises/practice/word-search/Sources/WordSearch/WordLocation.swift
@@ -0,0 +1,13 @@
+import Foundation
+
+struct WordLocation: Equatable {
+
+    struct Location: Equatable {
+        let row: Int
+        let column: Int
+    }
+
+    let start: Location
+    let end: Location 
+
+}
diff --git a/exercises/practice/word-search/Sources/WordSearch/WordSearch.swift b/exercises/practice/word-search/Sources/WordSearch/WordSearch.swift
new file mode 100644
index 00000000..38e59fd5
--- /dev/null
+++ b/exercises/practice/word-search/Sources/WordSearch/WordSearch.swift
@@ -0,0 +1,2 @@
+
+// Write your code for the 'WordSearch' exercise in this file.
\ No newline at end of file
diff --git a/exercises/practice/word-search/Tests/WordSearchTests/WordLocation+Initializer.swift b/exercises/practice/word-search/Tests/WordSearchTests/WordLocation+Initializer.swift
new file mode 100644
index 00000000..ad289775
--- /dev/null
+++ b/exercises/practice/word-search/Tests/WordSearchTests/WordLocation+Initializer.swift
@@ -0,0 +1,19 @@
+@testable import WordSearch
+
+extension WordLocation {
+
+    init?(start: [String: Int], end: [String: Int]) {
+        guard
+            let startRow = start["row"],
+            let startColumn = start["column"],
+            let endRow = end["row"],
+            let endColumn = end["column"]
+        else {
+            return nil
+        }
+        let start = Location(row: startRow, column: startColumn)
+        let end = Location(row: endRow, column: endColumn)
+        self.init(start: start, end: end)
+  }
+
+}
diff --git a/exercises/practice/word-search/Tests/WordSearchTests/WordSearchTests.swift b/exercises/practice/word-search/Tests/WordSearchTests/WordSearchTests.swift
new file mode 100644
index 00000000..f15c608f
--- /dev/null
+++ b/exercises/practice/word-search/Tests/WordSearchTests/WordSearchTests.swift
@@ -0,0 +1,524 @@
+import Foundation
+import Testing
+
+@testable import WordSearch
+
+let RUNALL = Bool(ProcessInfo.processInfo.environment["RUNALL", default: "false"]) ?? false
+
+@Suite struct WordSearchTests {
+
+  @Test("Should accept an initial game grid and a target search word")
+  func testShouldAcceptAnInitialGameGridAndATargetSearchWord() {
+    let grid = ["jefblpepre"]
+    let words = ["clojure"]
+
+    var expected = [String: WordLocation?]()
+    expected["clojure"] = nil
+
+    #expect(search(words: words, in: grid) == expected)
+  }
+
+  @Test("Should locate one word written left to right", .enabled(if: RUNALL))
+  func testShouldLocateOneWordWrittenLeftToRight() {
+    let grid = ["clojurermt"]
+    let words = ["clojure"]
+
+    var expected = [String: WordLocation?]()
+    expected["clojure"] = WordLocation(
+      start: ["column": 1, "row": 1],
+      end: ["column": 7, "row": 1]
+    )
+
+    #expect(search(words: words, in: grid) == expected)
+  }
+
+  @Test(
+    "Should locate the same word written left to right in a different position",
+    .enabled(if: RUNALL))
+  func testShouldLocateTheSameWordWrittenLeftToRightInADifferentPosition() {
+    let grid = ["mtclojurer"]
+    let words = ["clojure"]
+
+    var expected = [String: WordLocation?]()
+    expected["clojure"] = WordLocation(
+      start: ["column": 3, "row": 1],
+      end: ["column": 9, "row": 1]
+    )
+
+    #expect(search(words: words, in: grid) == expected)
+  }
+
+  @Test("Should locate a different left to right word", .enabled(if: RUNALL))
+  func testShouldLocateADifferentLeftToRightWord() {
+    let grid = ["coffeelplx"]
+    let words = ["coffee"]
+
+    var expected = [String: WordLocation?]()
+    expected["coffee"] = WordLocation(
+      start: ["column": 1, "row": 1],
+      end: ["column": 6, "row": 1]
+    )
+
+    #expect(search(words: words, in: grid) == expected)
+  }
+
+  @Test(
+    "Should locate that different left to right word in a different position", .enabled(if: RUNALL))
+  func testShouldLocateThatDifferentLeftToRightWordInADifferentPosition() {
+    let grid = ["xcoffeezlp"]
+    let words = ["coffee"]
+
+    var expected = [String: WordLocation?]()
+    expected["coffee"] = WordLocation(
+      start: ["column": 2, "row": 1],
+      end: ["column": 7, "row": 1]
+    )
+
+    #expect(search(words: words, in: grid) == expected)
+  }
+
+  @Test("Should locate a left to right word in two line grid", .enabled(if: RUNALL))
+  func testShouldLocateALeftToRightWordInTwoLineGrid() {
+    let grid = ["jefblpepre", "tclojurerm"]
+    let words = ["clojure"]
+
+    var expected = [String: WordLocation?]()
+    expected["clojure"] = WordLocation(
+      start: ["column": 2, "row": 2],
+      end: ["column": 8, "row": 2]
+    )
+
+    #expect(search(words: words, in: grid) == expected)
+  }
+
+  @Test("Should locate a left to right word in three line grid", .enabled(if: RUNALL))
+  func testShouldLocateALeftToRightWordInThreeLineGrid() {
+    let grid = ["camdcimgtc", "jefblpepre", "clojurermt"]
+    let words = ["clojure"]
+
+    var expected = [String: WordLocation?]()
+    expected["clojure"] = WordLocation(
+      start: ["column": 1, "row": 3],
+      end: ["column": 7, "row": 3]
+    )
+
+    #expect(search(words: words, in: grid) == expected)
+  }
+
+  @Test("Should locate a left to right word in ten line grid", .enabled(if: RUNALL))
+  func testShouldLocateALeftToRightWordInTenLineGrid() {
+    let grid = [
+      "jefblpepre", "camdcimgtc", "oivokprjsm", "pbwasqroua", "rixilelhrs", "wolcqlirpc",
+      "screeaumgr", "alxhpburyi", "jalaycalmp", "clojurermt",
+    ]
+    let words = ["clojure"]
+
+    var expected = [String: WordLocation?]()
+    expected["clojure"] = WordLocation(
+      start: ["column": 1, "row": 10],
+      end: ["column": 7, "row": 10]
+    )
+
+    #expect(search(words: words, in: grid) == expected)
+  }
+
+  @Test(
+    "Should locate that left to right word in a different position in a ten line grid",
+    .enabled(if: RUNALL))
+  func testShouldLocateThatLeftToRightWordInADifferentPositionInATenLineGrid() {
+    let grid = [
+      "jefblpepre", "camdcimgtc", "oivokprjsm", "pbwasqroua", "rixilelhrs", "wolcqlirpc",
+      "screeaumgr", "alxhpburyi", "clojurermt", "jalaycalmp",
+    ]
+    let words = ["clojure"]
+
+    var expected = [String: WordLocation?]()
+    expected["clojure"] = WordLocation(
+      start: ["column": 1, "row": 9],
+      end: ["column": 7, "row": 9]
+    )
+
+    #expect(search(words: words, in: grid) == expected)
+  }
+
+  @Test("Should locate a different left to right word in a ten line grid", .enabled(if: RUNALL))
+  func testShouldLocateADifferentLeftToRightWordInATenLineGrid() {
+    let grid = [
+      "jefblpepre", "camdcimgtc", "oivokprjsm", "pbwasqroua", "rixilelhrs", "wolcqlirpc",
+      "fortranftw", "alxhpburyi", "clojurermt", "jalaycalmp",
+    ]
+    let words = ["fortran"]
+
+    var expected = [String: WordLocation?]()
+    expected["fortran"] = WordLocation(
+      start: ["column": 1, "row": 7],
+      end: ["column": 7, "row": 7]
+    )
+
+    #expect(search(words: words, in: grid) == expected)
+  }
+
+  @Test("Should locate multiple words", .enabled(if: RUNALL))
+  func testShouldLocateMultipleWords() {
+    let grid = [
+      "jefblpepre", "camdcimgtc", "oivokprjsm", "pbwasqroua", "rixilelhrs", "wolcqlirpc",
+      "fortranftw", "alxhpburyi", "jalaycalmp", "clojurermt",
+    ]
+    let words = ["fortran", "clojure"]
+
+    var expected = [String: WordLocation?]()
+    expected["clojure"] = WordLocation(
+      start: ["column": 1, "row": 10],
+      end: ["column": 7, "row": 10]
+    )
+    expected["fortran"] = WordLocation(
+      start: ["column": 1, "row": 7],
+      end: ["column": 7, "row": 7]
+    )
+
+    #expect(search(words: words, in: grid) == expected)
+  }
+
+  @Test("Should locate a single word written right to left", .enabled(if: RUNALL))
+  func testShouldLocateASingleWordWrittenRightToLeft() {
+    let grid = ["rixilelhrs"]
+    let words = ["elixir"]
+
+    var expected = [String: WordLocation?]()
+    expected["elixir"] = WordLocation(
+      start: ["column": 6, "row": 1],
+      end: ["column": 1, "row": 1]
+    )
+
+    #expect(search(words: words, in: grid) == expected)
+  }
+
+  @Test(
+    "Should locate multiple words written in different horizontal directions", .enabled(if: RUNALL))
+  func testShouldLocateMultipleWordsWrittenInDifferentHorizontalDirections() {
+    let grid = [
+      "jefblpepre", "camdcimgtc", "oivokprjsm", "pbwasqroua", "rixilelhrs", "wolcqlirpc",
+      "screeaumgr", "alxhpburyi", "jalaycalmp", "clojurermt",
+    ]
+    let words = ["elixir", "clojure"]
+
+    var expected = [String: WordLocation?]()
+    expected["clojure"] = WordLocation(
+      start: ["column": 1, "row": 10],
+      end: ["column": 7, "row": 10]
+    )
+    expected["elixir"] = WordLocation(
+      start: ["column": 6, "row": 5],
+      end: ["column": 1, "row": 5]
+    )
+
+    #expect(search(words: words, in: grid) == expected)
+  }
+
+  @Test("Should locate words written top to bottom", .enabled(if: RUNALL))
+  func testShouldLocateWordsWrittenTopToBottom() {
+    let grid = [
+      "jefblpepre", "camdcimgtc", "oivokprjsm", "pbwasqroua", "rixilelhrs", "wolcqlirpc",
+      "screeaumgr", "alxhpburyi", "jalaycalmp", "clojurermt",
+    ]
+    let words = ["clojure", "elixir", "ecmascript"]
+
+    var expected = [String: WordLocation?]()
+    expected["clojure"] = WordLocation(
+      start: ["column": 1, "row": 10],
+      end: ["column": 7, "row": 10]
+    )
+    expected["ecmascript"] = WordLocation(
+      start: ["column": 10, "row": 1],
+      end: ["column": 10, "row": 10]
+    )
+    expected["elixir"] = WordLocation(
+      start: ["column": 6, "row": 5],
+      end: ["column": 1, "row": 5]
+    )
+
+    #expect(search(words: words, in: grid) == expected)
+  }
+
+  @Test("Should locate words written bottom to top", .enabled(if: RUNALL))
+  func testShouldLocateWordsWrittenBottomToTop() {
+    let grid = [
+      "jefblpepre", "camdcimgtc", "oivokprjsm", "pbwasqroua", "rixilelhrs", "wolcqlirpc",
+      "screeaumgr", "alxhpburyi", "jalaycalmp", "clojurermt",
+    ]
+    let words = ["clojure", "elixir", "ecmascript", "rust"]
+
+    var expected = [String: WordLocation?]()
+    expected["clojure"] = WordLocation(
+      start: ["column": 1, "row": 10],
+      end: ["column": 7, "row": 10]
+    )
+    expected["ecmascript"] = WordLocation(
+      start: ["column": 10, "row": 1],
+      end: ["column": 10, "row": 10]
+    )
+    expected["elixir"] = WordLocation(
+      start: ["column": 6, "row": 5],
+      end: ["column": 1, "row": 5]
+    )
+    expected["rust"] = WordLocation(
+      start: ["column": 9, "row": 5],
+      end: ["column": 9, "row": 2]
+    )
+
+    #expect(search(words: words, in: grid) == expected)
+  }
+
+  @Test("Should locate words written top left to bottom right", .enabled(if: RUNALL))
+  func testShouldLocateWordsWrittenTopLeftToBottomRight() {
+    let grid = [
+      "jefblpepre", "camdcimgtc", "oivokprjsm", "pbwasqroua", "rixilelhrs", "wolcqlirpc",
+      "screeaumgr", "alxhpburyi", "jalaycalmp", "clojurermt",
+    ]
+    let words = ["clojure", "elixir", "ecmascript", "rust", "java"]
+
+    var expected = [String: WordLocation?]()
+    expected["clojure"] = WordLocation(
+      start: ["column": 1, "row": 10],
+      end: ["column": 7, "row": 10]
+    )
+    expected["ecmascript"] = WordLocation(
+      start: ["column": 10, "row": 1],
+      end: ["column": 10, "row": 10]
+    )
+    expected["elixir"] = WordLocation(
+      start: ["column": 6, "row": 5],
+      end: ["column": 1, "row": 5]
+    )
+    expected["java"] = WordLocation(
+      start: ["column": 1, "row": 1],
+      end: ["column": 4, "row": 4]
+    )
+    expected["rust"] = WordLocation(
+      start: ["column": 9, "row": 5],
+      end: ["column": 9, "row": 2]
+    )
+
+    #expect(search(words: words, in: grid) == expected)
+  }
+
+  @Test("Should locate words written bottom right to top left", .enabled(if: RUNALL))
+  func testShouldLocateWordsWrittenBottomRightToTopLeft() {
+    let grid = [
+      "jefblpepre", "camdcimgtc", "oivokprjsm", "pbwasqroua", "rixilelhrs", "wolcqlirpc",
+      "screeaumgr", "alxhpburyi", "jalaycalmp", "clojurermt",
+    ]
+    let words = ["clojure", "elixir", "ecmascript", "rust", "java", "lua"]
+
+    var expected = [String: WordLocation?]()
+    expected["clojure"] = WordLocation(
+      start: ["column": 1, "row": 10],
+      end: ["column": 7, "row": 10]
+    )
+    expected["ecmascript"] = WordLocation(
+      start: ["column": 10, "row": 1],
+      end: ["column": 10, "row": 10]
+    )
+    expected["elixir"] = WordLocation(
+      start: ["column": 6, "row": 5],
+      end: ["column": 1, "row": 5]
+    )
+    expected["java"] = WordLocation(
+      start: ["column": 1, "row": 1],
+      end: ["column": 4, "row": 4]
+    )
+    expected["lua"] = WordLocation(
+      start: ["column": 8, "row": 9],
+      end: ["column": 6, "row": 7]
+    )
+    expected["rust"] = WordLocation(
+      start: ["column": 9, "row": 5],
+      end: ["column": 9, "row": 2]
+    )
+
+    #expect(search(words: words, in: grid) == expected)
+  }
+
+  @Test("Should locate words written bottom left to top right", .enabled(if: RUNALL))
+  func testShouldLocateWordsWrittenBottomLeftToTopRight() {
+    let grid = [
+      "jefblpepre", "camdcimgtc", "oivokprjsm", "pbwasqroua", "rixilelhrs", "wolcqlirpc",
+      "screeaumgr", "alxhpburyi", "jalaycalmp", "clojurermt",
+    ]
+    let words = ["clojure", "elixir", "ecmascript", "rust", "java", "lua", "lisp"]
+
+    var expected = [String: WordLocation?]()
+    expected["clojure"] = WordLocation(
+      start: ["column": 1, "row": 10],
+      end: ["column": 7, "row": 10]
+    )
+    expected["ecmascript"] = WordLocation(
+      start: ["column": 10, "row": 1],
+      end: ["column": 10, "row": 10]
+    )
+    expected["elixir"] = WordLocation(
+      start: ["column": 6, "row": 5],
+      end: ["column": 1, "row": 5]
+    )
+    expected["java"] = WordLocation(
+      start: ["column": 1, "row": 1],
+      end: ["column": 4, "row": 4]
+    )
+    expected["lisp"] = WordLocation(
+      start: ["column": 3, "row": 6],
+      end: ["column": 6, "row": 3]
+    )
+    expected["lua"] = WordLocation(
+      start: ["column": 8, "row": 9],
+      end: ["column": 6, "row": 7]
+    )
+    expected["rust"] = WordLocation(
+      start: ["column": 9, "row": 5],
+      end: ["column": 9, "row": 2]
+    )
+
+    #expect(search(words: words, in: grid) == expected)
+  }
+
+  @Test("Should locate words written top right to bottom left", .enabled(if: RUNALL))
+  func testShouldLocateWordsWrittenTopRightToBottomLeft() {
+    let grid = [
+      "jefblpepre", "camdcimgtc", "oivokprjsm", "pbwasqroua", "rixilelhrs", "wolcqlirpc",
+      "screeaumgr", "alxhpburyi", "jalaycalmp", "clojurermt",
+    ]
+    let words = ["clojure", "elixir", "ecmascript", "rust", "java", "lua", "lisp", "ruby"]
+
+    var expected = [String: WordLocation?]()
+    expected["clojure"] = WordLocation(
+      start: ["column": 1, "row": 10],
+      end: ["column": 7, "row": 10]
+    )
+    expected["ecmascript"] = WordLocation(
+      start: ["column": 10, "row": 1],
+      end: ["column": 10, "row": 10]
+    )
+    expected["elixir"] = WordLocation(
+      start: ["column": 6, "row": 5],
+      end: ["column": 1, "row": 5]
+    )
+    expected["java"] = WordLocation(
+      start: ["column": 1, "row": 1],
+      end: ["column": 4, "row": 4]
+    )
+    expected["lisp"] = WordLocation(
+      start: ["column": 3, "row": 6],
+      end: ["column": 6, "row": 3]
+    )
+    expected["lua"] = WordLocation(
+      start: ["column": 8, "row": 9],
+      end: ["column": 6, "row": 7]
+    )
+    expected["ruby"] = WordLocation(
+      start: ["column": 8, "row": 6],
+      end: ["column": 5, "row": 9]
+    )
+    expected["rust"] = WordLocation(
+      start: ["column": 9, "row": 5],
+      end: ["column": 9, "row": 2]
+    )
+
+    #expect(search(words: words, in: grid) == expected)
+  }
+
+  @Test("Should fail to locate a word that is not in the puzzle", .enabled(if: RUNALL))
+  func testShouldFailToLocateAWordThatIsNotInThePuzzle() {
+    let grid = [
+      "jefblpepre", "camdcimgtc", "oivokprjsm", "pbwasqroua", "rixilelhrs", "wolcqlirpc",
+      "screeaumgr", "alxhpburyi", "jalaycalmp", "clojurermt",
+    ]
+    let words = [
+      "clojure", "elixir", "ecmascript", "rust", "java", "lua", "lisp", "ruby", "haskell",
+    ]
+
+    var expected = [String: WordLocation?]()
+    expected["clojure"] = WordLocation(
+      start: ["column": 1, "row": 10],
+      end: ["column": 7, "row": 10]
+    )
+    expected["ecmascript"] = WordLocation(
+      start: ["column": 10, "row": 1],
+      end: ["column": 10, "row": 10]
+    )
+    expected["elixir"] = WordLocation(
+      start: ["column": 6, "row": 5],
+      end: ["column": 1, "row": 5]
+    )
+    expected["haskell"] = nil
+    expected["java"] = WordLocation(
+      start: ["column": 1, "row": 1],
+      end: ["column": 4, "row": 4]
+    )
+    expected["lisp"] = WordLocation(
+      start: ["column": 3, "row": 6],
+      end: ["column": 6, "row": 3]
+    )
+    expected["lua"] = WordLocation(
+      start: ["column": 8, "row": 9],
+      end: ["column": 6, "row": 7]
+    )
+    expected["ruby"] = WordLocation(
+      start: ["column": 8, "row": 6],
+      end: ["column": 5, "row": 9]
+    )
+    expected["rust"] = WordLocation(
+      start: ["column": 9, "row": 5],
+      end: ["column": 9, "row": 2]
+    )
+
+    #expect(search(words: words, in: grid) == expected)
+  }
+
+  @Test(
+    "Should fail to locate words that are not on horizontal, vertical, or diagonal lines",
+    .enabled(if: RUNALL))
+  func testShouldFailToLocateWordsThatAreNotOnHorizontalVerticalOrDiagonalLines() {
+    let grid = ["abc", "def"]
+    let words = ["aef", "ced", "abf", "cbd"]
+
+    var expected = [String: WordLocation?]()
+    expected["abf"] = nil
+    expected["aef"] = nil
+    expected["cbd"] = nil
+    expected["ced"] = nil
+
+    #expect(search(words: words, in: grid) == expected)
+  }
+
+  @Test("Should not concatenate different lines to find a horizontal word", .enabled(if: RUNALL))
+  func testShouldNotConcatenateDifferentLinesToFindAHorizontalWord() {
+    let grid = ["abceli", "xirdfg"]
+    let words = ["elixir"]
+
+    var expected = [String: WordLocation?]()
+    expected["elixir"] = nil
+
+    #expect(search(words: words, in: grid) == expected)
+  }
+
+  @Test("Should not wrap around horizontally to find a word", .enabled(if: RUNALL))
+  func testShouldNotWrapAroundHorizontallyToFindAWord() {
+    let grid = ["silabcdefp"]
+    let words = ["lisp"]
+
+    var expected = [String: WordLocation?]()
+    expected["lisp"] = nil
+
+    #expect(search(words: words, in: grid) == expected)
+  }
+
+  @Test("Should not wrap around vertically to find a word", .enabled(if: RUNALL))
+  func testShouldNotWrapAroundVerticallyToFindAWord() {
+    let grid = ["s", "u", "r", "a", "b", "c", "t"]
+    let words = ["rust"]
+
+    var expected = [String: WordLocation?]()
+    expected["rust"] = nil
+
+    #expect(search(words: words, in: grid) == expected)
+  }
+}