diff --git a/pysollib/gamedb.py b/pysollib/gamedb.py
index 2bc3703c1f..c7f4bfdbd5 100644
--- a/pysollib/gamedb.py
+++ b/pysollib/gamedb.py
@@ -600,8 +600,7 @@ def _callback(gi, gt=game_type):
 
     # deprecated - the correct way is to or a GI.GT_XXX flag
     # in the registerGame() call
-    _CHILDREN_GAMES = [16, 33, 55, 90, 91, 96, 97, 176, 328, 329, 862, 865,
-                       886, 903, ]
+    _CHILDREN_GAMES = []
 
     _OPEN_GAMES = []
 
diff --git a/pysollib/games/acesup.py b/pysollib/games/acesup.py
index a20fca0359..8597691146 100644
--- a/pysollib/games/acesup.py
+++ b/pysollib/games/acesup.py
@@ -504,7 +504,7 @@ def createGame(self):
 
 # register the game
 registerGame(GameInfo(903, AcesUp, "Aces Up",                   # was: 52
-                      GI.GT_1DECK_TYPE, 1, 0, GI.SL_LUCK,
+                      GI.GT_1DECK_TYPE | GI.GT_CHILDREN, 1, 0, GI.SL_LUCK,
                       altnames=("Aces High", "Drivel", "Discard")))
 registerGame(GameInfo(206, Fortunes, "Fortunes",
                       GI.GT_1DECK_TYPE, 1, 0, GI.SL_LUCK))
@@ -514,7 +514,7 @@ def createGame(self):
                       GI.GT_1DECK_TYPE, 1, -1, GI.SL_MOSTLY_LUCK,
                       altnames=("First Law", "Narcotic")))
 registerGame(GameInfo(353, AcesUp5, "Aces Up 5",
-                      GI.GT_1DECK_TYPE, 1, 0, GI.SL_LUCK))
+                      GI.GT_1DECK_TYPE | GI.GT_CHILDREN, 1, 0, GI.SL_LUCK))
 registerGame(GameInfo(552, Cover, "Cover",
                       GI.GT_1DECK_TYPE, 1, 0, GI.SL_LUCK))
 registerGame(GameInfo(583, FiringSquad, "Firing Squad",
diff --git a/pysollib/games/eiffeltower.py b/pysollib/games/eiffeltower.py
index b958661145..2b500ffa55 100644
--- a/pysollib/games/eiffeltower.py
+++ b/pysollib/games/eiffeltower.py
@@ -105,6 +105,7 @@ class StrictEiffelTower(EiffelTower):
 
 # register the game
 registerGame(GameInfo(16, EiffelTower, "Eiffel Tower",
-                      GI.GT_PAIRING_TYPE, 2, 0, GI.SL_MOSTLY_LUCK))
+                      GI.GT_PAIRING_TYPE | GI.GT_CHILDREN, 2, 0,
+                      GI.SL_MOSTLY_LUCK))
 # registerGame(GameInfo(801, StrictEiffelTower, "Strict Eiffel Tower",
 #                       GI.GT_PAIRING_TYPE, 2, 0))
diff --git a/pysollib/games/grandfathersclock.py b/pysollib/games/grandfathersclock.py
index 62014be2d3..47c41e9301 100644
--- a/pysollib/games/grandfathersclock.py
+++ b/pysollib/games/grandfathersclock.py
@@ -776,11 +776,11 @@ def getAutoStacks(self, event=None):
                       GI.GT_2DECK_TYPE, 2, 0, GI.SL_BALANCED,
                       altnames=("Father Time")))
 registerGame(GameInfo(737, Clock, "Clock",
-                      GI.GT_1DECK_TYPE, 1, 0, GI.SL_LUCK,
+                      GI.GT_1DECK_TYPE | GI.GT_CHILDREN, 1, 0, GI.SL_LUCK,
                       altnames=("Travellers", "Sundial")))
 registerGame(GameInfo(827, GermanClock, "German Clock",
                       GI.GT_1DECK_TYPE, 1, 1, GI.SL_MOSTLY_LUCK,
                       altnames=("Die Uhr",)))
 registerGame(GameInfo(915, RelaxedClock, "Relaxed Clock",
-                      GI.GT_1DECK_TYPE | GI.GT_RELAXED, 1, 0, GI.SL_LUCK,
-                      altnames=("Watch")))
+                      GI.GT_1DECK_TYPE | GI.GT_RELAXED | GI.GT_CHILDREN, 1, 0,
+                      GI.SL_LUCK, altnames=("Watch")))
diff --git a/pysollib/games/hitormiss.py b/pysollib/games/hitormiss.py
index 91db3d0c61..9e79ff0f39 100644
--- a/pysollib/games/hitormiss.py
+++ b/pysollib/games/hitormiss.py
@@ -170,5 +170,5 @@ class HitOrMissUnlimited(HitOrMiss):
                       GI.GT_1DECK_TYPE, 1, VARIABLE_REDEALS,
                       GI.SL_LUCK, altnames=("Roll Call",)))
 registerGame(GameInfo(865, HitOrMissUnlimited, "Hit or Miss Unlimited",
-                      GI.GT_1DECK_TYPE, 1, UNLIMITED_REDEALS,
+                      GI.GT_1DECK_TYPE | GI.GT_CHILDREN, 1, UNLIMITED_REDEALS,
                       GI.SL_LUCK))
diff --git a/pysollib/games/klondike.py b/pysollib/games/klondike.py
index 0a392f8d21..be0cbf77f0 100644
--- a/pysollib/games/klondike.py
+++ b/pysollib/games/klondike.py
@@ -1640,7 +1640,8 @@ def startGame(self):
 registerGame(GameInfo(224, Easthaven, "Easthaven",
                       GI.GT_GYPSY, 1, 0, GI.SL_MOSTLY_LUCK))
 registerGame(GameInfo(33, Westcliff, "Westcliff",
-                      GI.GT_KLONDIKE, 1, 0, GI.SL_MOSTLY_LUCK))
+                      GI.GT_KLONDIKE | GI.GT_CHILDREN, 1, 0,
+                      GI.SL_MOSTLY_LUCK))
 registerGame(GameInfo(225, Westhaven, "Westhaven",
                       GI.GT_GYPSY, 1, 0, GI.SL_BALANCED))
 registerGame(GameInfo(107, PasSeul, "Pas Seul",
diff --git a/pysollib/games/montecarlo.py b/pysollib/games/montecarlo.py
index b9a52ac66e..5d4c1f3a99 100644
--- a/pysollib/games/montecarlo.py
+++ b/pysollib/games/montecarlo.py
@@ -1118,15 +1118,16 @@ def isNeighbour(self, stack1, stack2):
 registerGame(GameInfo(212, Weddings, "Weddings",
                       GI.GT_PAIRING_TYPE, 1, 0, GI.SL_MOSTLY_LUCK))
 registerGame(GameInfo(90, SimpleCarlo, "Simple Carlo",
-                      GI.GT_PAIRING_TYPE, 1, 0, GI.SL_MOSTLY_LUCK))
+                      GI.GT_PAIRING_TYPE | GI.GT_CHILDREN, 1, 0,
+                      GI.SL_MOSTLY_LUCK))
 registerGame(GameInfo(91, SimplePairs, "Simple Pairs",
-                      GI.GT_PAIRING_TYPE, 1, 0, GI.SL_LUCK,
-                      altnames=("Jamestown", "Pirate Gold", "Treasure Hunt",
-                                "Hunter")))
+                      GI.GT_PAIRING_TYPE | GI.GT_CHILDREN, 1, 0,
+                      GI.SL_LUCK, altnames=("Jamestown", "Pirate Gold",
+                                            "Treasure Hunt", "Hunter")))
 registerGame(GameInfo(92, Neighbour, "Neighbour",
                       GI.GT_PAIRING_TYPE, 1, 0, GI.SL_MOSTLY_LUCK))
 registerGame(GameInfo(96, Fourteen, "Fourteen",
-                      GI.GT_PAIRING_TYPE | GI.GT_OPEN, 1, 0,
+                      GI.GT_PAIRING_TYPE | GI.GT_OPEN | GI.GT_CHILDREN, 1, 0,
                       GI.SL_MOSTLY_LUCK, altnames=("Fourteen Out",
                                                    "Fourteen Puzzle",
                                                    "Take Fourteen")))
@@ -1137,12 +1138,13 @@ def isNeighbour(self, stack1, stack2):
                       GI.GT_1DECK_TYPE | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL,
                       altnames=("Der letzte Monarch",)))
 registerGame(GameInfo(328, TheWish, "The Wish",
-                      GI.GT_PAIRING_TYPE | GI.GT_STRIPPED, 1, 0,
-                      GI.SL_MOSTLY_LUCK, ranks=(0, 6, 7, 8, 9, 10, 11, 12)))
+                      GI.GT_PAIRING_TYPE | GI.GT_STRIPPED | GI.GT_CHILDREN,
+                      1, 0, GI.SL_MOSTLY_LUCK,
+                      ranks=(0, 6, 7, 8, 9, 10, 11, 12)))
 registerGame(GameInfo(329, TheWishOpen, "The Wish (Open)",
                       GI.GT_PAIRING_TYPE | GI.GT_OPEN | GI.GT_ORIGINAL |
-                      GI.GT_STRIPPED, 1, 0, GI.SL_MOSTLY_SKILL,
-                      ranks=(0, 6, 7, 8, 9, 10, 11, 12),
+                      GI.GT_STRIPPED | GI.GT_CHILDREN, 1, 0,
+                      GI.SL_MOSTLY_SKILL, ranks=(0, 6, 7, 8, 9, 10, 11, 12),
                       rules_filename="thewish.html"))
 registerGame(GameInfo(368, Vertical, "Vertical",
                       GI.GT_PAIRING_TYPE | GI.GT_OPEN, 1, 0,
@@ -1162,8 +1164,8 @@ def isNeighbour(self, stack1, stack2):
 registerGame(GameInfo(829, BlockTen, "Block Ten",
                       GI.GT_PAIRING_TYPE, 1, 0, GI.SL_LUCK))
 registerGame(GameInfo(862, SimpleTens, "Simple Tens",
-                      GI.GT_PAIRING_TYPE | GI.GT_STRIPPED, 1, 0, GI.SL_LUCK,
-                      ranks=(0, 1, 2, 3, 4, 5, 6, 7, 8),
+                      GI.GT_PAIRING_TYPE | GI.GT_STRIPPED | GI.GT_CHILDREN,
+                      1, 0, GI.SL_LUCK, ranks=(0, 1, 2, 3, 4, 5, 6, 7, 8),
                       altnames=("Add Up Tens",)))
 registerGame(GameInfo(867, DoubleFourteen, "Double Fourteen",
                       GI.GT_PAIRING_TYPE | GI.GT_OPEN, 2, 0,
diff --git a/pysollib/games/royalcotillion.py b/pysollib/games/royalcotillion.py
index dafd4ad58e..2b99110409 100644
--- a/pysollib/games/royalcotillion.py
+++ b/pysollib/games/royalcotillion.py
@@ -1573,13 +1573,14 @@ def _autoDeal(self, sound=True):
                       GI.GT_2DECK_TYPE, 2, 0, GI.SL_LUCK,
                       altnames=("Lords and Ladies",)))
 registerGame(GameInfo(55, OddAndEven, "Odd and Even",
-                      GI.GT_2DECK_TYPE, 2, 1, GI.SL_LUCK))
+                      GI.GT_2DECK_TYPE | GI.GT_CHILDREN, 2, 1, GI.SL_LUCK))
 registerGame(GameInfo(143, Kingdom, "Kingdom",
                       GI.GT_2DECK_TYPE, 2, 0, GI.SL_MOSTLY_LUCK))
 registerGame(GameInfo(234, Alhambra, "Alhambra",
                       GI.GT_2DECK_TYPE, 2, 2, GI.SL_BALANCED))
 registerGame(GameInfo(97, Carpet, "Carpet",
-                      GI.GT_1DECK_TYPE, 1, 0, GI.SL_MOSTLY_LUCK))
+                      GI.GT_1DECK_TYPE | GI.GT_CHILDREN, 1, 0,
+                      GI.SL_MOSTLY_LUCK))
 registerGame(GameInfo(391, BritishConstitution, "British Constitution",
                       GI.GT_2DECK_TYPE | GI.GT_STRIPPED, 2, 0, GI.SL_BALANCED,
                       ranks=list(range(11)),  # without Queens and Kings
diff --git a/pysollib/games/special/memory.py b/pysollib/games/special/memory.py
index f57d179b03..bc085dc15b 100644
--- a/pysollib/games/special/memory.py
+++ b/pysollib/games/special/memory.py
@@ -392,12 +392,12 @@ def cardsMatch(self, card1, card2):
 
 # register the game
 registerGame(GameInfo(886, Memory16, "Memory 16",
-                      GI.GT_MEMORY | GI.GT_SCORE, 2, 0, GI.SL_SKILL,
-                      category=GI.GC_MATCHING,
+                      GI.GT_MEMORY | GI.GT_SCORE | GI.GT_CHILDREN, 2, 0,
+                      GI.SL_SKILL, category=GI.GC_MATCHING,
                       suits=(), ranks=(), trumps=list(range(8))))
 registerGame(GameInfo(176, Memory24, "Memory 24",
-                      GI.GT_MEMORY | GI.GT_SCORE, 2, 0, GI.SL_SKILL,
-                      category=GI.GC_MATCHING,
+                      GI.GT_MEMORY | GI.GT_SCORE | GI.GT_CHILDREN, 2, 0,
+                      GI.SL_SKILL, category=GI.GC_MATCHING,
                       suits=(), ranks=(), trumps=list(range(12))))
 registerGame(GameInfo(219, Memory30, "Memory 30",
                       GI.GT_MEMORY | GI.GT_SCORE, 2, 0, GI.SL_SKILL,