diff --git a/src/components/Puzzle.astro b/src/components/Puzzle.astro
new file mode 100644
index 0000000..684dddb
--- /dev/null
+++ b/src/components/Puzzle.astro
@@ -0,0 +1,565 @@
+<div class="puzzle-container">
+  <!-- Settings Trigger Button -->
+  <button class="settings-trigger" id="settingsToggle">
+    <svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+      <path
+        stroke-linecap="round"
+        stroke-linejoin="round"
+        stroke-width="2"
+        d="M10.325 4.317c.426-1.756 2.924-1.756 3.35 0a1.724 1.724 0 002.573 1.066c1.543-.94 3.31.826 2.37 2.37a1.724 1.724 0 001.065 2.572c1.756.426 1.756 2.924 0 3.35a1.724 1.724 0 00-1.066 2.573c.94 1.543-.826 3.31-2.37 2.37a1.724 1.724 0 00-2.572 1.065c-.426 1.756-2.924 1.756-3.35 0a1.724 1.724 0 00-2.573-1.066c-1.543.94-3.31-.826-2.37-2.37a1.724 1.724 0 00-1.065-2.572c-1.756-.426-1.756-2.924 0-3.35a1.724 1.724 0 001.066-2.573c-.94-1.543.826-3.31 2.37-2.37.996.608 2.296.07 2.572-1.065z"
+      ></path>
+      <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M15 12a3 3 0 11-6 0 3 3 0 016 0z"></path>
+    </svg>
+  </button>
+
+  <!-- Settings Panel -->
+  <div class="settings-panel" id="settingsPanel">
+    <div class="controls-group">
+      <button id="newPuzzleBtn" class="control-btn">
+        <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor">
+          <path d="M12 4v16m8-8H4" stroke-width="2" stroke-linecap="round"></path>
+        </svg>
+        New Puzzle
+      </button>
+      <button id="resetBtn" class="control-btn">
+        <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor">
+          <path d="M4 4v7h7M20 20v-7h-7" stroke-width="2" stroke-linecap="round"></path>
+        </svg>
+        Shuffle
+      </button>
+      <button id="clearBtn" class="control-btn">
+        <!--<svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor">
+          <path d="M19 7l-7 7-7-7" stroke-width="2" stroke-linecap="round"></path>
+        </svg>-->
+        Clear
+      </button>
+      <select id="difficultySelect" class="control-btn">
+        <option value="easy">Easy (Ages 3-5)</option>
+        <option value="medium">Medium (Ages 5-6)</option>
+        <option value="hard">Hard (Ages 7-8)</option>
+      </select>
+    </div>
+  </div>
+
+  <details>
+    <summary>Word List</summary>
+    <div class="word-list" id="wordList"></div>
+  </details>
+
+  <div class="stats-container">
+    <div class="stats-button">
+      <span>Clicks: <span id="clickCount">0</span></span>
+    </div>
+    <div class="stats-button">
+      <span>Found: <span id="foundCount">0</span>/<span id="totalWords"></span></span>
+    </div>
+    <button id="solutionBtn" class="control-btn">
+      <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor">
+        <path
+          d="M9.663 17h4.673M12 3v1m6.364 1.636l-.707.707M21 12h-1M4 12H3m3.343-5.657l-.707-.707m2.828 9.9a5 5 0 117.072 0l-.548.547A3.374 3.374 0 0014 18.469V19a2 2 0 11-4 0v-.531c0-.895-.356-1.754-.988-2.386l-.548-.547z"
+          stroke-width="2"
+          stroke-linecap="round"></path>
+      </svg>
+      Hint
+    </button>
+    <!-- Add Confirm Selection Button -->
+    <!--<button id="confirmSelectionBtn" class="control-btn"> Confirm Selection </button>-->
+  </div>
+
+  <div id="grid" class="grid"></div>
+</div>
+
+<script type="module">
+  import crosswordData from "/public/mocks/cross.json";
+
+  // Use the imported JSON data for word sets.
+  const wordSets = crosswordData;
+  let currentWordSetIndex = 0;
+
+  // Function to generate random colors with good contrast
+  function getRandomColor() {
+    // Changing the color generation for better visibility in help mode
+    // Using more pastel colors with higher lightness and lower alpha
+    const hue = Math.floor(Math.random() * 360); // Random hue (0-359)
+    const saturation = 80 + Math.floor(Math.random() * 15); // 80-95% saturation
+    const lightness = 70 + Math.floor(Math.random() * 15); // 70-85% lightness - lighter colors
+    const alpha = 0.7; // Slightly more opaque for better distinction
+    return `hsla(${hue}, ${saturation}%, ${lightness}%, ${alpha})`;
+  }
+
+  // Pre-generated color classes for found words
+  const colorClasses = [
+    "word-color-1",
+    "word-color-2",
+    "word-color-3",
+    "word-color-4",
+    "word-color-5",
+    "word-color-6",
+    "word-color-7",
+    "word-color-8"
+  ];
+
+  let state = {
+    difficulty: "easy",
+    grid: [],
+    size: 8,
+    selectedCells: [],
+    foundWords: [],
+    isDragging: false,
+    showSolution: false,
+    solutions: [],
+    clickCount: 0,
+    matchedCells: new Map(), // Changed to Map to store word-cells associations
+    currentWordSet: wordSets[0],
+    // We'll now store individual colors for each word in the solution
+    solutionColors: new Map(), // Map of word -> color
+    wordColors: new Map() // Track colors assigned to found words
+  };
+
+  function generateRandomLetter() {
+    return String.fromCharCode(65 + Math.floor(Math.random() * 26));
+  }
+
+  function getWordDirection(cells) {
+    const [[r1, c1], [r2, c2]] = [cells[0], cells[cells.length - 1]];
+    return r1 === r2 ? "horizontal" : c1 === c2 ? "vertical" : "diagonal";
+  }
+
+  function canPlaceWord(grid, word, row, col, dRow, dCol) {
+    if (row + dRow * (word.length - 1) >= state.size || row + dRow * (word.length - 1) < 0) return false;
+    if (col + dCol * (word.length - 1) >= state.size || col + dCol * (word.length - 1) < 0) return false;
+
+    for (let i = 0; i < word.length; i++) {
+      const currentCell = grid[row + dRow * i][col + dCol * i];
+      if (currentCell && currentCell !== word[i]) return false;
+    }
+    return true;
+  }
+
+  function placeWord(grid, word) {
+    const directions = [
+      [0, 1],
+      [1, 0],
+      [1, 1],
+      [1, -1]
+    ];
+    for (let attempt = 0; attempt < 200; attempt++) {
+      const [dRow, dCol] = directions[Math.floor(Math.random() * directions.length)];
+      const row = Math.floor(Math.random() * state.size);
+      const col = Math.floor(Math.random() * state.size);
+
+      if (canPlaceWord(grid, word, row, col, dRow, dCol)) {
+        const wordCells = [];
+        for (let i = 0; i < word.length; i++) {
+          const r = row + dRow * i;
+          const c = col + dCol * i;
+          grid[r][c] = word[i];
+          wordCells.push([r, c]);
+        }
+        return { placed: true, cells: wordCells, direction: getWordDirection(wordCells) };
+      }
+    }
+    return { placed: false, cells: [], direction: null };
+  }
+
+  function generateRandomColors() {
+    // Clear existing solution colors
+    state.solutionColors.clear();
+
+    // Define a set of distinct, high-contrast colors for better help visibility
+    // Using a predefined palette for help mode instead of fully random colors
+    const helpColorPalette = [
+      "hsla(10, 90%, 75%, 0.75)", // Light red
+      "hsla(40, 90%, 75%, 0.75)", // Light amber
+      "hsla(60, 90%, 75%, 0.75)", // Light yellow
+      "hsla(120, 90%, 75%, 0.75)", // Light green
+      "hsla(180, 90%, 75%, 0.75)", // Light cyan
+      "hsla(210, 90%, 75%, 0.75)", // Light blue
+      "hsla(270, 90%, 75%, 0.75)", // Light purple
+      "hsla(300, 90%, 75%, 0.75)", // Light magenta
+      "hsla(330, 90%, 75%, 0.75)", // Light pink
+      "hsla(150, 90%, 75%, 0.75)", // Light teal
+      "hsla(30, 90%, 75%, 0.75)", // Light orange
+      "hsla(240, 90%, 75%, 0.75)" // Light indigo
+    ];
+
+    // Assign colors to words, trying to use different colors for adjacent words
+    let colorIndex = 0;
+    state.solutions.forEach((solution) => {
+      state.solutionColors.set(solution.word, helpColorPalette[colorIndex % helpColorPalette.length]);
+      colorIndex++;
+    });
+  }
+
+  function resetPuzzle() {
+    generatePuzzleWithCurrentWordSet();
+  }
+
+  function generatePuzzleWithCurrentWordSet() {
+    // Adjust grid size based on difficulty
+    // For now, we'll keep the grid size constant for all difficulties
+    // We can adjust this based on the difficulty level in the future
+    // change size according to needs
+    switch (state.difficulty) {
+      case "easy":
+        state.size = 8;
+        break;
+      case "medium":
+        state.size = 8;
+        break;
+      case "hard":
+        state.size = 8;
+        break;
+    }
+
+    const newGrid = Array(state.size)
+      .fill()
+      .map(() => Array(state.size).fill(""));
+    const words = state.currentWordSet[state.difficulty];
+    state.solutions = [];
+    state.wordColors.clear();
+    state.matchedCells.clear();
+    state.solutionColors.clear();
+
+    words.forEach((word) => {
+      const result = placeWord(newGrid, word);
+      if (result.placed) {
+        state.solutions.push({ word, cells: result.cells, direction: result.direction });
+        // Assign a random color to each word solution
+        state.solutionColors.set(word, getRandomColor());
+      }
+    });
+
+    for (let i = 0; i < state.size; i++) {
+      for (let j = 0; j < state.size; j++) {
+        newGrid[i][j] = newGrid[i][j] || generateRandomLetter();
+      }
+    }
+
+    state.grid = newGrid;
+    state.foundWords = [];
+    state.showSolution = false;
+    state.selectedCells = [];
+    state.clickCount = 0;
+
+    updateDOM();
+  }
+
+  function generateNewPuzzle() {
+    currentWordSetIndex = (currentWordSetIndex + 1) % wordSets.length;
+    state.currentWordSet = wordSets[currentWordSetIndex];
+    generatePuzzleWithCurrentWordSet();
+  }
+
+  function isValidNextCell(current, next) {
+    const [r1, c1] = current;
+    const [r2, c2] = next;
+    return Math.abs(r1 - r2) <= 1 && Math.abs(c1 - c2) <= 1;
+  }
+
+  function checkForWord(selection) {
+    if (selection.length < 3) return false;
+
+    const word = selection.map(([r, c]) => state.grid[r][c]).join("");
+    const reverseWord = word.split("").reverse().join("");
+    const currentWords = state.currentWordSet[state.difficulty];
+
+    let foundWord = null;
+    if (currentWords.includes(word) && !state.foundWords.includes(word)) {
+      foundWord = word;
+    } else if (currentWords.includes(reverseWord) && !state.foundWords.includes(reverseWord)) {
+      foundWord = reverseWord;
+    }
+
+    if (foundWord) {
+      state.foundWords.push(foundWord);
+      // Assign a color to the word
+      if (!state.wordColors.has(foundWord)) {
+        const colorIndex = state.wordColors.size % colorClasses.length;
+        state.wordColors.set(foundWord, colorClasses[colorIndex]);
+      }
+      // Store the cells associated with this word
+      state.matchedCells.set(foundWord, [...selection]); // Create a copy of the selection
+      return true;
+    }
+    return false;
+  }
+
+  function getCellCoordinates(element) {
+    if (!element?.dataset?.coords) return null;
+    return element.dataset.coords.split("-").map(Number);
+  }
+
+  function updateDOM() {
+    const gridElement = document.getElementById("grid");
+    gridElement.innerHTML = "";
+    gridElement.style.gridTemplateColumns = `repeat(${state.size}, 1fr)`;
+
+    state.grid.forEach((row, i) =>
+      row.forEach((cell, j) => {
+        const cellElement = document.createElement("div");
+        cellElement.className = "cell";
+        cellElement.textContent = cell;
+        cellElement.dataset.coords = `${i}-${j}`;
+
+        const isSelected = state.selectedCells.some(([r, c]) => r === i && c === j);
+
+        // Find if this cell belongs to any found word
+        let matchedWord = null;
+        for (const [word, cells] of state.matchedCells.entries()) {
+          if (cells.some(([r, c]) => r === i && c === j)) {
+            matchedWord = word;
+            break;
+          }
+        }
+
+        // Check if this cell is part of a solution
+        if (state.showSolution) {
+          // Find which solution word this cell belongs to
+          for (const solution of state.solutions) {
+            if (solution.cells.some(([r, c]) => r === i && c === j)) {
+              // Apply the unique color for this word
+              const wordColor = state.solutionColors.get(solution.word);
+              if (wordColor) {
+                cellElement.style.backgroundColor = wordColor;
+              }
+              break;
+            }
+          }
+        }
+
+        if (isSelected) cellElement.classList.add("selected");
+        if (matchedWord) {
+          cellElement.classList.add("match");
+          const colorClass = state.wordColors.get(matchedWord);
+          if (colorClass) {
+            cellElement.classList.add(colorClass);
+          }
+        }
+
+        gridElement.appendChild(cellElement);
+      })
+    );
+
+    document.getElementById("clickCount").textContent = state.clickCount;
+    document.getElementById("foundCount").textContent = state.foundWords.length;
+    document.getElementById("totalWords").textContent = state.currentWordSet[state.difficulty].length;
+
+    const wordList = document.getElementById("wordList");
+    wordList.innerHTML = state.currentWordSet[state.difficulty]
+      .map((word) => {
+        const isFound = state.foundWords.includes(word);
+        const colorClass = state.wordColors.get(word) || "";
+
+        // For words in solution mode, set the background color directly
+        let style = "";
+        if (state.showSolution) {
+          const solutionColor = state.solutionColors.get(word);
+          if (solutionColor) {
+            style = `style="background-color: ${solutionColor};"`;
+          }
+        }
+
+        return `<span class="word ${isFound ? "found " + colorClass : ""}" ${style}>${word}</span>`;
+      })
+      .join("");
+  }
+
+  function handleCellClick(e) {
+    const coords = getCellCoordinates(e.target);
+    if (!coords) return;
+
+    // Check if the cell is already selected
+    const isAlreadySelected = state.selectedCells.some(([r, c]) => r === coords[0] && c === coords[1]);
+
+    if (isAlreadySelected) {
+      // If the cell is already selected, do nothing
+      return;
+    }
+
+    // Add the new cell to the selection
+    state.selectedCells.push(coords);
+    state.clickCount++;
+
+    // Update the DOM to reflect the new selection
+    updateDOM();
+  }
+
+  //function handleConfirmSelection() {
+  //  if (state.selectedCells.length >= 3) {
+  //    const foundWord = checkForWord(state.selectedCells);
+  //    if (foundWord) {
+  //      setTimeout(() => {
+  //        state.selectedCells = [];
+  //        updateDOM();
+  //      }, 1000);
+  //    } else {
+  //      state.selectedCells = [];
+  //      updateDOM();
+  //    }
+  //  } else {
+  //    state.selectedCells = [];
+  //    updateDOM();
+  //  }
+  //}
+
+  function handleDragStart(e) {
+    const coords = getCellCoordinates(e.target);
+    if (!coords) return;
+
+    state.isDragging = true;
+    state.selectedCells = [coords];
+    state.clickCount++;
+    updateDOM();
+  }
+
+  function handleDragMove(e) {
+    if (!state.isDragging) return;
+
+    const element = document.elementFromPoint(
+      e.type.includes("touch") ? e.touches[0].clientX : e.clientX,
+      e.type.includes("touch") ? e.touches[0].clientY : e.clientY
+    );
+
+    const coords = getCellCoordinates(element);
+    if (!coords) return;
+
+    const lastCell = state.selectedCells[state.selectedCells.length - 1];
+    if (!lastCell || !isValidNextCell(lastCell, coords)) return;
+
+    if (!state.selectedCells.some(([r, c]) => r === coords[0] && c === coords[1])) {
+      state.selectedCells.push(coords);
+      updateDOM();
+    }
+  }
+
+  function handleDragEnd() {
+    if (!state.isDragging) return;
+
+    const wasWordFound = checkForWord(state.selectedCells);
+    state.isDragging = false;
+
+    if (!wasWordFound) {
+      state.selectedCells = [];
+    }
+
+    updateDOM();
+  }
+
+  // Function to handle help button click
+  function handleHelpButtonClick() {
+    // Generate new random colors for each word
+    generateRandomColors();
+
+    // Toggle solution display
+    state.showSolution = !state.showSolution;
+
+    // Update the DOM
+    updateDOM();
+  }
+  function handleClearButtonClick() {
+    state.selectedCells = [];
+    state.foundWords = [];
+    state.matchedCells.clear();
+    state.wordColors.clear();
+    state.isDragging = false;
+
+    updateDOM();
+  }
+
+  // Function to handle difficulty change
+  function handleDifficultyChange(e) {
+    state.difficulty = e.target.value;
+    generatePuzzleWithCurrentWordSet();
+  }
+
+  document.addEventListener("DOMContentLoaded", () => {
+    const gridElement = document.getElementById("grid");
+
+    // Add cell click handler for sequential selection
+    gridElement.addEventListener("click", handleCellClick);
+
+    // Add event listener for the Confirm Selection button
+    //document.getElementById("confirmSelectionBtn").addEventListener("click", handleConfirmSelection);
+
+    // Mouse events for drag selection
+    gridElement.addEventListener("mousedown", handleDragStart);
+    gridElement.addEventListener("mousemove", handleDragMove);
+    document.addEventListener("mouseup", handleDragEnd);
+
+    // Touch events
+    gridElement.addEventListener("touchstart", (e) => {
+      e.preventDefault();
+      handleDragStart(e);
+    });
+
+    gridElement.addEventListener("touchmove", (e) => {
+      e.preventDefault();
+      handleDragMove(e);
+    });
+
+    gridElement.addEventListener("touchend", (e) => {
+      e.preventDefault();
+      handleDragEnd();
+    });
+
+    // Controls
+    document.getElementById("difficultySelect").addEventListener("change", handleDifficultyChange);
+    document.getElementById("newPuzzleBtn").addEventListener("click", generateNewPuzzle);
+    document.getElementById("resetBtn").addEventListener("click", resetPuzzle);
+    document.getElementById("solutionBtn").addEventListener("click", handleHelpButtonClick);
+
+    document.getElementById("clearBtn").addEventListener("click", handleClearButtonClick);
+
+    // Initialize the first puzzle
+    generatePuzzleWithCurrentWordSet();
+  });
+
+  // Wait for the DOM to be fully loaded
+  document.addEventListener("DOMContentLoaded", function () {
+    // Get the settings elements
+    const settingsToggle = document.getElementById("settingsToggle");
+    const settingsPanel = document.getElementById("settingsPanel");
+    let isSettingsOpen = false;
+
+    // Toggle settings panel
+    settingsToggle.addEventListener("click", function (e) {
+      e.stopPropagation(); // Prevent event from bubbling
+      isSettingsOpen = !isSettingsOpen;
+
+      if (isSettingsOpen) {
+        settingsPanel.classList.add("active");
+        settingsToggle.classList.add("active");
+      } else {
+        settingsPanel.classList.remove("active");
+        settingsToggle.classList.remove("active");
+      }
+    });
+
+    // Close settings when clicking outside
+    document.addEventListener("click", function (e) {
+      if (isSettingsOpen && !settingsPanel.contains(e.target) && !settingsToggle.contains(e.target)) {
+        settingsPanel.classList.remove("active");
+        settingsToggle.classList.remove("active");
+        isSettingsOpen = false;
+      }
+    });
+
+    // Prevent settings panel clicks from closing the panel
+    settingsPanel.addEventListener("click", function (e) {
+      e.stopPropagation();
+    });
+
+    // Add smooth transitions for details elements
+    document.querySelectorAll("details").forEach((detail) => {
+      detail.addEventListener("toggle", function (e) {
+        if (detail.open) {
+          const content = detail.querySelector("summary + *");
+          if (content) {
+            content.style.maxHeight = content.scrollHeight + "px";
+          }
+        }
+      });
+    });
+  });
+</script>
diff --git a/public/mocks/crossword-data.json b/src/data/crossword-data.json
similarity index 100%
rename from public/mocks/crossword-data.json
rename to src/data/crossword-data.json
diff --git a/src/pages/crossword.astro b/src/pages/crossword.astro
index 93c1339..dcee4bf 100644
--- a/src/pages/crossword.astro
+++ b/src/pages/crossword.astro
@@ -1,21 +1,20 @@
 ---
 import "@/assets/styles/crossword.css";
-import crosswordData from '../../public/mocks/crossword-data.json';
+import Help from "@/components/Help.astro";
 import WordSearchPuzzle from "@/components/Puzzle.astro";
+import crosswordData from "@/data/crossword-data.json";
 import BaseLayout from "@/layouts/Base";
-import Help from "@/components/Help.astro";
 
 const categories = crosswordData.categories;
 let selectedCategory = null;
-let words: any= [];
-
+let words: any = [];
 
 const selectCategory = (category: string) => {
   selectedCategory = category;
   words = (crosswordData as any).words[category] || [];
 };
-
 ---
+
 <BaseLayout meta={{ title: "Crossword" }}>
   <Fragment slot="header-right">
     <Help
@@ -24,5 +23,5 @@ const selectCategory = (category: string) => {
     />
   </Fragment>
 
-    <WordSearchPuzzle/>
-</BaseLayout>
\ No newline at end of file
+  <WordSearchPuzzle />
+</BaseLayout>
diff --git a/src/pages/varnmala/english.astro b/src/pages/varnmala/english.astro
index df315ca..55e999b 100644
--- a/src/pages/varnmala/english.astro
+++ b/src/pages/varnmala/english.astro
@@ -13,64 +13,6 @@ import BackButton from "@/components/ui/backButton.astro";
     />
   </Fragment>
   <BackButton />
-  <article class="container__english">
-    <div class="controls" id="controls">
-      <div class="control-group">
-        <label>Bg:</label>
-        <select id="bgSelector">
-          <option value="none">None</option>
-          <option value="gradient1">G1</option>
-          <option value="gradient2">G2</option>
-          <option value="pattern1">P1</option>
-        </select>
-        <button id="toggleBg">Toggle</button>
-      </div>
-
-      <div class="control-group">
-        <label>Font:</label>
-        <select id="fontSelector">
-          <option value="Arial">Arial</option>
-          <option value="Georgia">Georgia</option>
-          <option value="Times New Roman">Times</option>
-        </select>
-        <input type="color" id="colorPicker" value="#000000" />
-      </div>
-    </div>
-    <Help
-      title="Hindi Varnmala"
-      description="Just press any letter fron keyboard and it display the letter and it's relative word in clear way and if you type again it will change the color"
-    />
-  </Fragment>
-  <BackButton />
-  <article class="container__english">
-    <div class="controls" id="controls">
-      <div class="control-group">
-        <label>Bg:</label>
-        <select id="bgSelector">
-          <option value="none">None</option>
-          <option value="gradient1">G1</option>
-          <option value="gradient2">G2</option>
-          <option value="pattern1">P1</option>
-        </select>
-        <button id="toggleBg">Toggle</button>
-      </div>
-
-      <div class="control-group">
-        <label>Font:</label>
-        <select id="fontSelector">
-          <option value="Arial">Arial</option>
-          <option value="Georgia">Georgia</option>
-          <option value="Times New Roman">Times</option>
-        </select>
-        <input type="color" id="colorPicker" value="#000000" />
-      </div>
-    </div>
-    <Help
-      title="Hindi Varnmala"
-      description="Just press any letter fron keyboard and it display the letter and it's relative word in clear way and if you type again it will change the color"
-    />
-  </Fragment>
-  <BackButton />
   <article class="container__english">
     <article class="container__hindi" id="letterContainer">
       <div class="letter">A</div>
diff --git a/src/utils/constants.ts b/src/utils/constants.ts
index 3025f2a..ae7350e 100644
--- a/src/utils/constants.ts
+++ b/src/utils/constants.ts
@@ -61,13 +61,6 @@ export const NavbarLinks: LinkProps[] = [
     path: "/feedback",
     isActive: true
   },
-  {
-    name: "Feedback",
-    title: "Feedback Form",
-    path: "/feedback",
-    isActive: true
-  },
-  { name: "crossword", title: "Crossword", path: "/crossword", isActive: true },
   {
     name: "Societree",
     title: "Clan",