diff --git a/cooperative_cuisine/environment.py b/cooperative_cuisine/environment.py
index 224440ce0fcb27428265fa2f14073b8f8146b3af..bee2f95f9b217c1b66bea0783c8b470f2d7d3732 100644
--- a/cooperative_cuisine/environment.py
+++ b/cooperative_cuisine/environment.py
@@ -218,6 +218,13 @@ class Environment:
         """Counters that needs to be called in the step function via the `progress` method."""
         self.overwrite_counters(self.counters)
 
+        do_validation = (
+            self.environment_config["game"]["validate_recipes"]
+            if "validate_recipes" in self.environment_config["game"].keys()
+            else True
+        )
+
+        print("DO VALIDATION", do_validation)
         self.recipe_validation = Validation(
             meals=[m for m in self.item_info.values() if m.type == ItemType.Meal]
             if self.environment_config["meals"]["all"]
@@ -228,30 +235,13 @@ class Environment:
             ],
             item_info=self.item_info,
             order_manager=self.order_manager,
+            do_validation=do_validation,
         )
 
-        if (
-            "validate_recipes" in self.environment_config["game"].keys()
-            and self.environment_config["game"]["validate_recipes"]
-        ):
-            meals_to_be_ordered = self.recipe_validation.validate_environment(
-                self.counters
-            )
-            assert meals_to_be_ordered, "Need possible meals for order generation."
-        else:
-            all_meals = {
-                meal_name: meal_info
-                for meal_name, meal_info in self.item_info.items()
-                if meal_info.type == ItemType.Meal
-            }
-            set_meals = {
-                n: self.item_info[n] for n in self.environment_config["meals"]["list"]
-            }
-            meals_to_be_ordered = (
-                set_meals if not self.environment_config["meals"]["all"] else all_meals
-            )
-
+        meals_to_be_ordered = self.recipe_validation.validate_environment(self.counters)
+        print("meals_to_be_ordered:", meals_to_be_ordered)
         assert meals_to_be_ordered, "Need possible meals for order generation."
+
         available_meals = {meal: self.item_info[meal] for meal in meals_to_be_ordered}
 
         self.order_manager.set_available_meals(available_meals)
diff --git a/cooperative_cuisine/game_server.py b/cooperative_cuisine/game_server.py
index f92edefb2daa64a8596fd53ab5861aa909d89b95..b27683c77f5bdff0f981fef429a643b48a9d95b5 100644
--- a/cooperative_cuisine/game_server.py
+++ b/cooperative_cuisine/game_server.py
@@ -40,7 +40,6 @@ from cooperative_cuisine.utils import (
     url_and_port_arguments,
     add_list_of_manager_ids_arguments,
     disable_websocket_logging_arguments,
-    setup_logging,
 )
 
 log = logging.getLogger(__name__)
@@ -770,7 +769,7 @@ async def websocket_player_endpoint(websocket: WebSocket, client_id: str):
 def main(
     host: str, port: int, manager_ids: list[str], enable_websocket_logging: bool = False
 ):
-    setup_logging(enable_websocket_logging)
+    # setup_logging(enable_websocket_logging)
     loop = asyncio.new_event_loop()
     asyncio.set_event_loop(loop)
     environment_handler.extend_allowed_manager(manager_ids)
diff --git a/cooperative_cuisine/validation.py b/cooperative_cuisine/validation.py
index 07c4f6617b45f87af38de69bd7f1423a8db9e4a2..0bd0ff2e807509726fdd649fa1aca24a1666e3aa 100644
--- a/cooperative_cuisine/validation.py
+++ b/cooperative_cuisine/validation.py
@@ -1,6 +1,5 @@
 import os
 import warnings
-from concurrent.futures import ThreadPoolExecutor
 from typing import TypedDict, Tuple, Iterator
 
 import networkx as nx
@@ -25,10 +24,17 @@ class MealGraphDict(TypedDict):
 
 
 class Validation:
-    def __init__(self, meals, item_info, order_manager):
+    def __init__(
+        self,
+        meals: list[ItemInfo],
+        item_info: dict[str, ItemInfo],
+        order_manager: OrderManager,
+        do_validation: bool,
+    ):
         self.meals: list[ItemInfo] = meals
         self.item_info: dict[str, ItemInfo] = item_info
         self.order_manager: OrderManager = order_manager
+        self.do_validation: bool = do_validation
 
     @staticmethod
     def infer_recipe_graph(item_info) -> DiGraph:
@@ -243,40 +249,47 @@ class Validation:
         return layout_requirements
 
     def validate_environment(self, counters: list[Counter]):
-        graph = self.infer_recipe_graph(self.item_info)
-        os.makedirs(ROOT_DIR / "generated", exist_ok=True)
-        nx.nx_agraph.to_agraph(graph).draw(
-            ROOT_DIR / "generated" / "recipe_graph.png", format="png", prog="dot"
-        )
+        print("DO", self.do_validation)
+        if self.do_validation:
+            graph = self.infer_recipe_graph(self.item_info)
+            os.makedirs(ROOT_DIR / "generated", exist_ok=True)
+            nx.nx_agraph.to_agraph(graph).draw(
+                ROOT_DIR / "generated" / "recipe_graph.png", format="png", prog="dot"
+            )
 
-        expected = self.get_item_info_requirements()
-        present = self.get_layout_requirements(counters)
-        possible_meals = set(meal for meal in expected if expected[meal] <= present)
-        defined_meals = set(map(lambda i: i.name, self.meals))
+            expected = self.get_item_info_requirements()
+            present = self.get_layout_requirements(counters)
+            possible_meals = set(meal for meal in expected if expected[meal] <= present)
+            defined_meals = set(map(lambda i: i.name, self.meals))
 
-        # print(f"Ordered meals: {defined_meals}, Possible meals: {possible_meals}")
-        if len(defined_meals - possible_meals) > 0:
-            warnings.warn(
-                f"Ordered meals are not possible: {defined_meals - possible_meals}"
-            )
+            # print(f"Ordered meals: {defined_meals}, Possible meals: {possible_meals}")
+            if len(defined_meals - possible_meals) > 0:
+                warnings.warn(
+                    f"Ordered meals are not possible: {defined_meals - possible_meals}"
+                )
 
-        meals_to_be_ordered = possible_meals.intersection(defined_meals)
-        return meals_to_be_ordered
-        # print("FINAL MEALS:", meals_to_be_ordered)
+            meals_to_be_ordered = possible_meals.intersection(defined_meals)
+            return meals_to_be_ordered
+        else:
+            return {m.name for m in self.meals}
 
     def get_recipe_graphs(self) -> list[MealGraphDict]:
         if not self.order_manager.available_meals:
             return []
         os.makedirs(ROOT_DIR / "generated", exist_ok=True)
 
-        # time_start = time.time()
-        with ThreadPoolExecutor(
-            max_workers=len(self.order_manager.available_meals)
-        ) as executor:
-            graph_dicts = list(
-                executor.map(
-                    self.get_meal_graph, self.order_manager.available_meals.values()
-                )
-            )
-        # print("DURATION", time.time() - time_start)
-        return graph_dicts
+        return [
+            self.get_meal_graph(m) for m in self.order_manager.available_meals.values()
+        ]
+
+        # # time_start = time.time()
+        # with ThreadPoolExecutor(
+        #     max_workers=len(self.order_manager.available_meals)
+        # ) as executor:
+        #     graph_dicts = list(
+        #         executor.map(
+        #             self.get_meal_graph, self.order_manager.available_meals.values()
+        #         )
+        #     )
+        # # print("DURATION", time.time() - time_start)
+        # return graph_dicts