diff --git a/ChangeLog.md b/ChangeLog.md
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -1,5 +1,9 @@
 # Revision history for greskell
 
+## 2.0.3.0  -- 2023-02-24
+
+* Add `GTraversal.Gen` module (see https://github.com/debug-ito/greskell/issues/15 )
+
 ## 2.0.2.0  -- 2023-01-11
 
 * Add `oDesc` and `oAsc` functions (`Gremlin` module) ( https://github.com/debug-ito/greskell/pull/14 )
diff --git a/greskell.cabal b/greskell.cabal
--- a/greskell.cabal
+++ b/greskell.cabal
@@ -1,5 +1,5 @@
 name:                   greskell
-version:                2.0.2.0
+version:                2.0.3.0
 author:                 Toshio Ito <debug.ito@gmail.com>
 maintainer:             Toshio Ito <debug.ito@gmail.com>
 license:                BSD3
@@ -33,6 +33,7 @@
                         Data.Greskell.Graph,
                         Data.Greskell.Graph.PropertyMap,
                         Data.Greskell.GTraversal,
+                        Data.Greskell.GTraversal.Gen,
                         Data.Greskell.AsLabel,
                         Data.Greskell.Extra,
                         Data.Greskell.PMap,
diff --git a/src/Data/Greskell.hs b/src/Data/Greskell.hs
--- a/src/Data/Greskell.hs
+++ b/src/Data/Greskell.hs
@@ -14,6 +14,7 @@
 --   class of non-empty containers.
 -- - "Data.Greskell.Logic": Logic type, which is a general-purpose logic tree data structure.
 -- - "Data.Greskell.Graph.PropertyMap": deprecated PropertyMap class.
+-- - "Data.Greskell.GTraversal.Gen": an experimental module that has generalized versions of Gremlin traversals defined in "Data.Greskell.GTraversal".
 module Data.Greskell
     ( module Data.Greskell.Greskell
     , module Data.Greskell.Binder
diff --git a/src/Data/Greskell/GTraversal/Gen.hs b/src/Data/Greskell/GTraversal/Gen.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Greskell/GTraversal/Gen.hs
@@ -0,0 +1,364 @@
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE TypeFamilies     #-}
+-- | __This module is experimental. It may have breaking changes in future.__
+--
+-- This module has Gremlin traversals defined in 'Data.Greskell.GTraversal' generalized on the
+-- walk type. It may save you from calling 'liftWalk' manually.
+--
+-- @since 2.0.3.0
+module Data.Greskell.GTraversal.Gen
+    ( -- * Types
+      -- ** GraphTraversal and others
+      GTraversal (..)
+    , GraphTraversal
+    , ToGTraversal (..)
+    , Walk
+    , GraphTraversalSource
+      -- ** Walk types
+    , WalkType
+    , Filter
+    , Transform
+    , SideEffect
+    , Lift
+    , Split
+      -- * GraphTraversalSource
+    , source
+    , sV
+    , sV'
+    , sE
+    , sE'
+    , sAddV
+    , sAddV'
+      -- * GTraversal
+    , (&.)
+    , ($.)
+    , (<$.>)
+    , (<*.>)
+    , gIterate
+    , unsafeGTraversal
+      -- * Walk/Steps
+    , unsafeWalk
+    , modulateWith
+      -- ** Filter steps
+    , gIdentity
+    , gFilter
+    , gCyclicPath
+    , gSimplePath
+      -- ** Is step
+    , gIs
+    , gIsP
+      -- ** Has steps
+    , gHas1
+    , gHas2
+    , gHas2P
+    , gHasLabel
+    , gHasLabelP
+    , gHasId
+    , gHasIdP
+    , gHasKey
+    , gHasKeyP
+    , gHasValue
+    , gHasValueP
+      -- ** Logic steps
+    , gAnd
+    , gOr
+    , gNot
+      -- ** Where step
+    , gWhereP1
+    , gWhereP2
+      -- ** Sorting steps
+    , gOrder
+      -- ** Paging steps
+    , gRange
+    , gLimit
+    , gTail
+    , gSkip
+      -- ** Repeat step
+    , gRepeat
+    , gTimes
+    , gUntilHead
+    , gUntilTail
+    , gEmitHead
+    , gEmitTail
+    , gEmitHeadT
+    , gEmitTailT
+    , gLoops
+    , RepeatUntil (..)
+    , RepeatEmit (..)
+    , RepeatPos (..)
+    , RepeatLabel (..)
+      -- ** Branching steps
+    , gLocal
+    , gUnion
+    , gCoalesce
+    , gChoose3
+      -- ** Barrier steps
+    , gBarrier
+    , gDedup
+    , gDedupN
+      -- ** Transformation steps
+    , gFlatMap
+    , gV
+    , gV'
+    , gConstant
+    , gProject
+      -- ** As step
+    , gAs
+      -- ** Accessor steps
+    , gValues
+    , gProperties
+    , gId
+    , gLabel
+    , gValueMap
+    , gElementMap
+    , gSelect1
+    , gSelectN
+    , gSelectBy1
+    , gSelectByN
+    , gUnfold
+    , gPath
+    , gPathBy
+      -- ** Summarizing steps
+    , gFold
+    , gCount
+      -- ** Graph traversal steps
+    , gOut
+    , gOut'
+    , gOutE
+    , gOutE'
+    , gOutV
+    , gOutV'
+    , gIn
+    , gIn'
+    , gInE
+    , gInE'
+    , gInV
+    , gInV'
+      -- ** Match step
+    , gMatch
+    , MatchPattern (..)
+    , mPattern
+    , MatchResult
+      -- ** Side-effect steps
+    , gSideEffect
+      -- ** Graph manipulation steps
+    , gAddV
+    , gAddV'
+    , gAddE
+    , gAddE'
+    , AddAnchor
+    , gFrom
+    , gTo
+    , gDrop
+    , gDropP
+    , gProperty
+    , gPropertyV
+      -- ** @.by@ steps
+    , ByProjection (..)
+    , ProjectionLike (..)
+    , ByComparator (..)
+    , LabeledByProjection (..)
+    , gBy
+    , gBy1
+    , gBy2
+    , gByL
+    ) where
+
+import           Data.Text                (Text)
+
+import           Data.Greskell.AsIterator (AsIterator (IteratorItem))
+import           Data.Greskell.AsLabel    (AsLabel, LabeledP, SelectedMap)
+import           Data.Greskell.Graph      (AEdge, AVertex, Cardinality, Edge, Element (..),
+                                           ElementID, Key, KeyValue, Keys, Path, Property, Vertex)
+import           Data.Greskell.GraphSON   (GValue)
+import           Data.Greskell.Greskell   (Greskell)
+import           Data.Greskell.GTraversal (AddAnchor, ByComparator (..), ByProjection (..), Filter,
+                                           GTraversal (..), GraphTraversal, GraphTraversalSource,
+                                           LabeledByProjection (..), Lift, MatchPattern (..),
+                                           MatchResult, ProjectionLike (..), RepeatEmit (..),
+                                           RepeatLabel (..), RepeatPos (..), RepeatUntil (..),
+                                           SideEffect, Split, ToGTraversal (..), Transform, Walk,
+                                           WalkType, gAnd, gBarrier, gBy, gBy1, gBy2, gByL,
+                                           gChoose3, gCoalesce, gCyclicPath, gEmitHead, gEmitHeadT,
+                                           gEmitTail, gEmitTailT, gFilter, gFlatMap, gHas1, gHas2,
+                                           gHas2P, gHasId, gHasIdP, gHasKey, gHasKeyP, gHasLabel,
+                                           gHasLabelP, gHasValue, gHasValueP, gIdentity, gIs, gIsP,
+                                           gIterate, gLocal, gNot, gOr, gRepeat, gSideEffect,
+                                           gSimplePath, gTimes, gUnion, gUntilHead, gUntilTail,
+                                           gWhereP1, gWhereP2, mPattern, modulateWith, source,
+                                           unsafeGTraversal, unsafeWalk, ($.), (&.), (<$.>), (<*.>))
+import qualified Data.Greskell.GTraversal as G
+import           Data.Greskell.Logic      (Logic)
+import           Data.Greskell.PMap       (PMap, Single)
+
+sV :: (Vertex v, WalkType c, Lift Transform c) => [Greskell (ElementID v)] -> Greskell GraphTraversalSource -> GTraversal c () v
+sV a b = liftWalk $ G.sV a b
+
+sV' :: (WalkType c, Lift Transform c) => [Greskell (ElementID AVertex)] -> Greskell GraphTraversalSource -> GTraversal c () AVertex
+sV' = sV
+
+sE :: (Edge e, WalkType c, Lift Transform c) => [Greskell (ElementID e)] -> Greskell GraphTraversalSource -> GTraversal c () e
+sE a b = liftWalk $ G.sE a b
+
+sE' :: (WalkType c, Lift Transform c) => [Greskell (ElementID AEdge)] -> Greskell GraphTraversalSource -> GTraversal c () AEdge
+sE' = sE
+
+sAddV :: (Vertex v, WalkType c, Lift SideEffect c) => Greskell Text -> Greskell GraphTraversalSource -> GTraversal c () v
+sAddV a b = liftWalk $ G.sAddV a b
+
+sAddV' :: (WalkType c, Lift SideEffect c) => Greskell Text -> Greskell GraphTraversalSource -> GTraversal c () AVertex
+sAddV' = sAddV
+
+gOrder :: (WalkType c, Lift Transform c) => [ByComparator s] -> Walk c s s
+gOrder b = liftWalk $ G.gOrder b
+
+gRange :: (WalkType c, Lift Transform c) => Greskell Int -> Greskell Int -> Walk c s s
+gRange a b = liftWalk $ G.gRange a b
+
+gLimit :: (WalkType c, Lift Transform c) => Greskell Int -> Walk c s s
+gLimit a = liftWalk $ G.gLimit a
+
+gTail :: (WalkType c, Lift Transform c) => Greskell Int -> Walk c s s
+gTail a = liftWalk $ G.gTail a
+
+gSkip :: (WalkType c, Lift Transform c) => Greskell Int -> Walk c s s
+gSkip a = liftWalk $ G.gSkip a
+
+gLoops :: (WalkType c, Lift Transform c) => Maybe RepeatLabel -> Walk c s Int
+gLoops a = liftWalk $ G.gLoops a
+
+gDedup :: (WalkType c, Lift Transform c) => Maybe (ByProjection s e) -> Walk c s s
+gDedup a =  liftWalk $ G.gDedup a
+
+gDedupN :: (WalkType c, Lift Transform c) => AsLabel a -> [AsLabel a] -> Maybe (ByProjection a e) -> Walk c s s
+gDedupN a b c = liftWalk $ G.gDedupN a b c
+
+gV :: (Vertex v, WalkType c, Lift Transform c) => [Greskell (ElementID v)] -> Walk c s v
+gV a = liftWalk $ G.gV a
+
+gV' :: (WalkType c, Lift Transform c) => [Greskell (ElementID AVertex)] -> Walk c s AVertex
+gV' = gV
+
+gConstant :: (WalkType c, Lift Transform c) => Greskell a -> Walk c s a
+gConstant a = liftWalk $ G.gConstant a
+
+gProject :: (WalkType c, Lift Transform c) => LabeledByProjection s -> [LabeledByProjection s] -> Walk c s (PMap Single GValue)
+gProject a b = liftWalk $ G.gProject a b
+
+gAs :: (WalkType c, Lift Transform c) => AsLabel a -> Walk c a a
+gAs a = liftWalk $ G.gAs a
+
+gValues :: (Element s, WalkType c, Lift Transform c) => [Key s e] -> Walk c s e
+gValues a = liftWalk $ G.gValues a
+
+gProperties :: (Element s, Property p, ElementProperty s ~ p, WalkType c, Lift Transform c) => [Key s v] -> Walk c s (p v)
+gProperties a = liftWalk $ G.gProperties a
+
+gId :: (Element s, WalkType c, Lift Transform c) => Walk c s (ElementID s)
+gId = liftWalk G.gId
+
+gLabel :: (Element s, WalkType c, Lift Transform c) => Walk c s Text
+gLabel = liftWalk G.gLabel
+
+gValueMap :: (Element s, WalkType c, Lift Transform c) => Keys s -> Walk c s (PMap (ElementPropertyContainer s) GValue)
+gValueMap a = liftWalk $ G.gValueMap a
+
+gElementMap :: (Element s, WalkType c, Lift Transform c) => Keys s -> Walk c s (PMap Single GValue)
+gElementMap a = liftWalk $ G.gElementMap a
+
+gSelect1 :: (WalkType c, Lift Transform c) => AsLabel a -> Walk c s a
+gSelect1 a = liftWalk $ G.gSelect1 a
+
+gSelectN :: (WalkType c, Lift Transform c) => AsLabel a -> AsLabel b -> [AsLabel c] -> Walk c s (SelectedMap GValue)
+gSelectN a b c = liftWalk $ G.gSelectN a b c
+
+gSelectBy1 :: (WalkType c, Lift Transform c) => AsLabel a -> ByProjection a b -> Walk c s b
+gSelectBy1 a b = liftWalk $ G.gSelectBy1 a b
+
+gSelectByN :: (WalkType c, Lift Transform c) => AsLabel a -> AsLabel a -> [AsLabel a] -> ByProjection a b -> Walk c s (SelectedMap b)
+gSelectByN a b c d = liftWalk $ G.gSelectByN a b c d
+
+gUnfold :: (AsIterator a, WalkType c, Lift Transform c) => Walk c a (IteratorItem a)
+gUnfold = liftWalk $ G.gUnfold
+
+gPath :: (WalkType c, Lift Transform c) => Walk c s (Path GValue)
+gPath = liftWalk $ G.gPath
+
+gPathBy :: (WalkType c, Lift Transform c) => ByProjection a b -> [ByProjection a b] -> Walk c s (Path b)
+gPathBy a b = liftWalk $ G.gPathBy a b
+
+gFold :: (WalkType c, Lift Transform c) => Walk c a [a]
+gFold = liftWalk $ G.gFold
+
+gCount :: (WalkType c, Lift Transform c) => Walk c a Int
+gCount = liftWalk $ G.gCount
+
+gOut :: (Vertex v1, Vertex v2, WalkType c, Lift Transform c) => [Greskell Text] -> Walk c v1 v2
+gOut a = liftWalk $ G.gOut a
+
+gOut' :: (Vertex v, WalkType c, Lift Transform c) => [Greskell Text] -> Walk c v AVertex
+gOut' = gOut
+
+gOutE :: (Vertex v, Edge e, WalkType c, Lift Transform c) => [Greskell Text] -> Walk c v e
+gOutE a = liftWalk $ G.gOutE a
+
+gOutE' :: (Vertex v, WalkType c, Lift Transform c) => [Greskell Text] -> Walk c v AEdge
+gOutE' = gOutE
+
+gOutV :: (Edge e, Vertex v, WalkType c, Lift Transform c) => Walk c e v
+gOutV = liftWalk $ G.gOutV
+
+gOutV' :: (Edge e, WalkType c, Lift Transform c) => Walk c e AVertex
+gOutV' = gOutV
+
+gIn :: (Vertex v1, Vertex v2, WalkType c, Lift Transform c) => [Greskell Text] -> Walk c v1 v2
+gIn a = liftWalk $ G.gIn a
+
+gIn' :: (Vertex v, WalkType c, Lift Transform c) => [Greskell Text] -> Walk c v AVertex
+gIn' = gIn
+
+gInE :: (Vertex v, Edge e, WalkType c, Lift Transform c) => [Greskell Text] -> Walk c v e
+gInE a = liftWalk $ G.gInE a
+
+gInE' :: (Vertex v, WalkType c, Lift Transform c) => [Greskell Text] -> Walk c v AEdge
+gInE' = gInE
+
+gInV :: (Edge e, Vertex v, WalkType c, Lift Transform c) => Walk c e v
+gInV = liftWalk $ G.gInV
+
+gInV' :: (Edge e, WalkType c, Lift Transform c) => Walk c e AVertex
+gInV' = gInV
+
+gMatch :: (WalkType c, Lift Transform c) => Logic MatchPattern -> Walk c a MatchResult
+gMatch a = liftWalk $ G.gMatch a
+
+gAddV :: (Vertex v, WalkType c, Lift SideEffect c) => Greskell Text -> Walk c a v
+gAddV a = liftWalk $ G.gAddV a
+
+gAddV' :: (WalkType c, Lift SideEffect c) => Greskell Text -> Walk c a AVertex
+gAddV' = gAddV
+
+gAddE :: (Vertex vs, Vertex ve, Edge e, WalkType c, Lift SideEffect c) => Greskell Text -> AddAnchor vs ve -> Walk c vs e
+gAddE a b = liftWalk $ G.gAddE a b
+
+gAddE' :: (WalkType c, Lift SideEffect c) => Greskell Text -> AddAnchor AVertex AVertex -> Walk c AVertex AEdge
+gAddE' = gAddE
+
+gFrom :: (ToGTraversal g, WalkType c, Lift c Transform) => g c s e -> AddAnchor s e
+gFrom a = G.gFrom $ liftWalk a
+
+gTo :: (ToGTraversal g, WalkType c, Lift c Transform) => g c s e -> AddAnchor s e
+gTo a = G.gTo $ liftWalk a
+
+gDrop :: (Element e, WalkType c, Lift SideEffect c) => Walk c e e
+gDrop = liftWalk G.gDrop
+
+gDropP :: (Property p, WalkType c, Lift SideEffect c) => Walk c (p a) (p a)
+gDropP = liftWalk G.gDropP
+
+gProperty :: (Element e, WalkType c, Lift SideEffect c) => Key e v -> Greskell v -> Walk c e e
+gProperty a b = liftWalk $ G.gProperty a b
+
+gPropertyV :: (Vertex e, vp ~ ElementProperty e, Property vp, Element (vp v), WalkType c, Lift SideEffect c)
+           => Maybe (Greskell Cardinality) -> Key e v -> Greskell v -> [KeyValue (vp v)] -> Walk c e e
+gPropertyV a b c d = liftWalk $ G.gPropertyV a b c d