You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tinkerpop.apache.org by xi...@apache.org on 2025/12/22 21:44:58 UTC

(tinkerpop) branch go-http-converge-conn-lang created (now 4393a5a3b8)

This is an automated email from the ASF dual-hosted git repository.

xiazcy pushed a change to branch go-http-converge-conn-lang
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git


      at 4393a5a3b8 fix various gremlinlang and serializer bugs in go for http

This branch includes the following new commits:

     new a2395a5705 * Added GremlinLang to go driver to replace Bytecode. Clean up and updates will be needed when connection is set up. * update graph binary serializer to 4.0.0 spec * Updated datetime, added GValue, updated Options strategy, removed unneeded strategy package name, added NewTraversalStrategy to allow custom strategies. (#3056) * Replace websockets with http. Changed connection pooling to be delegated to aio http library. Added POC changes to request serialization just to [...]
     new 4393a5a3b8 fix various gremlinlang and serializer bugs in go for http

The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.



(tinkerpop) 01/02: * Added GremlinLang to go driver to replace Bytecode. Clean up and updates will be needed when connection is set up. * update graph binary serializer to 4.0.0 spec * Updated datetime, added GValue, updated Options strategy, removed unneeded strategy package name, added NewTraversalStrategy to allow custom strategies. (#3056) * Replace websockets with http. Changed connection pooling to be delegated to aio http library. Added POC changes to request serialization just to make happy path work [...]

Posted by xi...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

xiazcy pushed a commit to branch go-http-converge-conn-lang
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git

commit a2395a57052a2c9ded0f4d0fc54af211b06b9d1d
Author: Yang Xia <55...@users.noreply.github.com>
AuthorDate: Mon Jan 27 18:28:00 2025 -0800

    * Added GremlinLang to go driver to replace Bytecode. Clean up and updates will be needed when connection is set up.
    * update graph binary serializer to 4.0.0 spec
    * Updated datetime, added GValue, updated Options strategy, removed unneeded strategy package name, added NewTraversalStrategy to allow custom strategies. (#3056)
    * Replace websockets with http. Changed connection pooling to be delegated to aio http library. Added POC changes to request serialization just to make happy path work. Full connection configuration and response chunking not yet implemented. (#3057)
    * update gremlinlang to use slices to store instructions instead
    * update strategies test after gremlinlang change
    * update serializer to use marker
    * fix strategies translation and add missing strategies
    * Remove result set map container as it is no longer needed.
    * Removed concept of session as it is no longer needed.
    * Read response status code from graph binary response.
    * Removed response status attributes as they no longer exist.
    * Read response status message and exception strings.
    * Remove gremlin-socket-server from docker compose.
    * Removed socket server tests.
    * Changed transporter to delegate most of the request creation to client library by using http.NewRequest. Removed requestId as it's no longer used. Made some small logging changes.
    * Removed unused request op attribute.
    * Removed unused request processor.
    * Added some comments, refactored error handling and resource closing.
    * Removed reference to partial content status code. Added some comments and did some minor cleanup.
    * Removed reference to response metadata.
    * Removed unused synchronized mpa.
    * Removed tests for custom type serialization. Removed response id as it is no longer used. Adjusted expected serialized request bytes according to TP4 format. Adjusted bytes for testing deserialization according to TP4 format. Removed serializer unwrapping of single item results as it was causing serialization test to fail. (#3066)
---
 .../language/translator/GoTranslateVisitor.java    |   4 +-
 .../language/translator/GremlinTranslatorTest.java |  12 +-
 gremlin-go/driver/anonymousTraversal.go            |   2 +-
 gremlin-go/driver/client.go                        |  28 +-
 gremlin-go/driver/connection_test.go               | 167 +++--
 gremlin-go/driver/driverRemoteConnection.go        |  13 +-
 gremlin-go/driver/error_codes.go                   |   7 +-
 gremlin-go/driver/gValue.go                        |  61 ++
 gremlin-go/driver/gValue_test.go                   |  87 +++
 gremlin-go/driver/graphBinary.go                   | 520 +++------------
 gremlin-go/driver/graphBinary_test.go              |  29 +-
 gremlin-go/driver/graphTraversal.go                | 285 ++++----
 gremlin-go/driver/graphTraversalSource.go          |  66 +-
 gremlin-go/driver/graphTraversalSource_test.go     |  30 +-
 gremlin-go/driver/gremlinlang.go                   | 538 ++++++++++++++++
 gremlin-go/driver/gremlinlang_test.go              | 715 +++++++++++++++++++++
 gremlin-go/driver/httpProtocol.go                  | 154 +++++
 gremlin-go/driver/httpTransporter.go               | 138 ++--
 gremlin-go/driver/logger.go                        |   5 +-
 gremlin-go/driver/{transporter.go => marker.go}    |  38 +-
 gremlin-go/driver/request.go                       |   2 +-
 .../driver/resources/logger-messages/en.json       |   7 +-
 gremlin-go/driver/response.go                      |   3 -
 gremlin-go/driver/serializer.go                    |  86 +--
 gremlin-go/driver/serializer_test.go               |  75 +--
 gremlin-go/driver/strategies.go                    | 115 ++--
 gremlin-go/driver/strategies_test.go               |  34 +-
 gremlin-go/driver/traversal.go                     |  58 +-
 gremlin-go/driver/traversal_test.go                |   4 +-
 gremlin-go/pom.xml                                 |  75 ++-
 30 files changed, 2275 insertions(+), 1083 deletions(-)

diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/translator/GoTranslateVisitor.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/translator/GoTranslateVisitor.java
index 69f368b935..0cd864b751 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/translator/GoTranslateVisitor.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/translator/GoTranslateVisitor.java
@@ -23,6 +23,7 @@ import org.antlr.v4.runtime.tree.ParseTree;
 import org.antlr.v4.runtime.tree.TerminalNode;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.tinkerpop.gremlin.language.grammar.GremlinParser;
+import org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy;
 import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.OptionsStrategy;
 import org.apache.tinkerpop.gremlin.structure.VertexProperty;
 import org.apache.tinkerpop.gremlin.util.DatetimeHelper;
@@ -41,7 +42,8 @@ public class GoTranslateVisitor extends AbstractTranslateVisitor {
     private final static List<String> STRATEGY_WITH_MAP_OPTS = Collections.unmodifiableList(Arrays.asList(
             "OptionsStrategy",
             "ReferenceElementStrategy", "ComputerFinalizationStrategy", "ProfileStrategy",
-            "ComputerVerificationStrategy", "StandardVerificationStrategy", "VertexProgramRestrictionStrategy"));
+            "ComputerVerificationStrategy", "StandardVerificationStrategy", "VertexProgramRestrictionStrategy",
+            "MessagePassingReductionStrategy"));
     private final static List<String> STRATEGY_WITH_STRING_SLICE = Collections.unmodifiableList(Arrays.asList(
             "ReservedKeysVerificationStrategy", "ProductiveByStrategy"));
 
diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/translator/GremlinTranslatorTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/translator/GremlinTranslatorTest.java
index f08355d1a2..d89dba51b4 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/translator/GremlinTranslatorTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/translator/GremlinTranslatorTest.java
@@ -699,13 +699,23 @@ public class GremlinTranslatorTest {
                     {"g.withStrategies(ReservedKeysVerificationStrategy(throwException: true, keys: [\"age\"])).addV(\"person\").property(\"age\", 29).property(\"name\", \"marko\")",
                             "g.withStrategies(ReservedKeysVerificationStrategy(throwException:true, keys:[\"age\"])).addV(\"person\").property(\"age\", 29).property(\"name\", \"marko\")",
                             "g.withStrategies(ReservedKeysVerificationStrategy(throwException:boolean0, keys:list0)).addV(string0).property(string1, number0).property(string2, string3)",
-                            "g.WithStrategies(new ReservedKeysVerificationStrategy(throwException: true, keys: new List<object> { \"age\" })).AddV((string) \"person\").Property(\"age\", 29).Property(\"name\", \"marko\")",
+                            "g.WithStrategies(new ReservedKeysVerificationStrategy(throwException: true, keys: new List<object> { \"age\" })).AddV(\"person\").Property(\"age\", 29).Property(\"name\", \"marko\")",
                             "g.WithStrategies(gremlingo.ReservedKeysVerificationStrategy(gremlingo.ReservedKeysVerificationStrategyConfig{ThrowException: true, Keys: []string{\"age\"}})).AddV(\"person\").Property(\"age\", 29).Property(\"name\", \"marko\")",
                             "g.withStrategies(new ReservedKeysVerificationStrategy(throwException:true, keys:[\"age\"])).addV(\"person\").property(\"age\", 29).property(\"name\", \"marko\")",
                             "g.withStrategies(ReservedKeysVerificationStrategy.build().throwException(true).keys(new ArrayList<Object>() {{ add(\"age\"); }}).create()).addV(\"person\").property(\"age\", 29).property(\"name\", \"marko\")",
                             "g.withStrategies(new ReservedKeysVerificationStrategy({throwException: true, keys: [\"age\"]})).addV(\"person\").property(\"age\", 29).property(\"name\", \"marko\")",
                             "g.with_strategies(ReservedKeysVerificationStrategy(throw_exception=True, keys=['age'])).add_v('person').property('age', 29).property('name', 'marko')"
                     },
+                    {"g.withStrategies(OptionsStrategy(myVar: \"myValue\")).V()",
+                            "g.withStrategies(OptionsStrategy(myVar:\"myValue\")).V()",
+                            "g.withStrategies(OptionsStrategy(myVar:string0)).V()",
+                            "g.WithStrategies(new OptionsStrategy(myVar: \"myValue\")).V()",
+                            "g.WithStrategies(gremlingo.OptionsStrategy(map[string]interface{}{\"myVar\": \"myValue\"})).V()",
+                            "g.withStrategies(new OptionsStrategy(myVar:\"myValue\")).V()",
+                            "g.withStrategies(OptionsStrategy.build().myVar(\"myValue\").create()).V()",
+                            "g.withStrategies(new OptionsStrategy({myVar: \"myValue\"})).V()",
+                            "g.with_strategies(OptionsStrategy(my_var='myValue')).V()"
+                    },
                     {"g.withoutStrategies(ReadOnlyStrategy, PathRetractionStrategy, FilterRankingStrategy)",
                             null,
                             null,
diff --git a/gremlin-go/driver/anonymousTraversal.go b/gremlin-go/driver/anonymousTraversal.go
index 1e049b3dff..45166b8cfc 100644
--- a/gremlin-go/driver/anonymousTraversal.go
+++ b/gremlin-go/driver/anonymousTraversal.go
@@ -337,7 +337,7 @@ type anonymousTraversal struct {
 
 var T__ AnonymousTraversal = &anonymousTraversal{
 	func() *GraphTraversal {
-		return NewGraphTraversal(nil, NewBytecode(nil), nil)
+		return NewGraphTraversal(nil, NewGremlinLang(nil), nil)
 	},
 }
 
diff --git a/gremlin-go/driver/client.go b/gremlin-go/driver/client.go
index ff625f6dff..12b6c4e9c6 100644
--- a/gremlin-go/driver/client.go
+++ b/gremlin-go/driver/client.go
@@ -63,7 +63,7 @@ type Client struct {
 	traversalSource    string
 	logHandler         *logHandler
 	connectionSettings *connectionSettings
-	gremlinClient      *gremlinClient
+	httpProtocol       *httpProtocol
 }
 
 // NewClient creates a Client and configures it with the given parameters.
@@ -104,14 +104,14 @@ func NewClient(url string, configurations ...func(settings *ClientSettings)) (*C
 
 	logHandler := newLogHandler(settings.Logger, settings.LogVerbosity, settings.Language)
 
-	gc := newGremlinClient(logHandler, url, connSettings)
+	httpProt := newHttpProtocol(logHandler, url, connSettings)
 
 	client := &Client{
 		url:                url,
 		traversalSource:    settings.TraversalSource,
 		logHandler:         logHandler,
 		connectionSettings: connSettings,
-		gremlinClient:      gc,
+		httpProtocol:       httpProt,
 	}
 
 	return client, nil
@@ -120,8 +120,12 @@ func NewClient(url string, configurations ...func(settings *ClientSettings)) (*C
 // Close closes the client via connection.
 // This is idempotent due to the underlying close() methods being idempotent as well.
 func (client *Client) Close() {
+	// TODO check what needs to be closed
 	client.logHandler.logf(Info, closeClient, client.url)
-	client.gremlinClient.close()
+}
+
+func (client *Client) errorCallback() {
+	client.logHandler.log(Error, errorCallback)
 }
 
 // SubmitWithOptions submits a Gremlin script to the server with specified RequestOptions and returns a ResultSet.
@@ -130,8 +134,8 @@ func (client *Client) SubmitWithOptions(traversalString string, requestOptions R
 	request := makeStringRequest(traversalString, client.traversalSource, requestOptions)
 
 	// TODO interceptors (ie. auth)
-
-	rs, err := client.gremlinClient.send(&request)
+	
+	rs, err := client.httpProtocol.send(&request)
 	return rs, err
 }
 
@@ -146,9 +150,19 @@ func (client *Client) Submit(traversalString string, bindings ...map[string]inte
 	return client.SubmitWithOptions(traversalString, requestOptionsBuilder.Create())
 }
 
+// submitGremlinLang submits GremlinLang to the server to execute and returns a ResultSet.
+// TODO test and update when connection is set up
+func (client *Client) submitGremlinLang(gremlinLang *GremlinLang) (ResultSet, error) {
+	client.logHandler.logf(Debug, submitStartedString, *gremlinLang)
+	// TODO placeholder
+	requestOptionsBuilder := new(RequestOptionsBuilder)
+	request := makeStringRequest(gremlinLang.GetGremlin(), client.traversalSource, requestOptionsBuilder.Create())
+	return client.httpProtocol.send(&request)
+}
+
 // submitBytecode submits Bytecode to the server to execute and returns a ResultSet.
 func (client *Client) submitBytecode(bytecode *Bytecode) (ResultSet, error) {
 	client.logHandler.logf(Debug, submitStartedBytecode, *bytecode)
 	request := makeBytecodeRequest(bytecode, client.traversalSource)
-	return client.gremlinClient.send(&request)
+	return client.httpProtocol.send(&request)
 }
diff --git a/gremlin-go/driver/connection_test.go b/gremlin-go/driver/connection_test.go
index c0b80fde03..d24c6158ff 100644
--- a/gremlin-go/driver/connection_test.go
+++ b/gremlin-go/driver/connection_test.go
@@ -47,6 +47,7 @@ const nonRoutableIPForConnectionTimeout = "http://10.255.255.1/"
 
 // transaction is enabled on the same port as no auth url
 const noAuthUrl = "http://localhost:45940/gremlin"
+const noAuthSslUrl = "https://localhost:45941/gremlin"
 const basicAuthWithSsl = "wss://localhost:45941/gremlin"
 
 var testNames = []string{"Lyndon", "Yang", "Simon", "Rithin", "Alexey", "Valentyn"}
@@ -272,6 +273,55 @@ func TestConnection(t *testing.T) {
 	testBasicAuthAuthInfo := getBasicAuthInfo()
 	testBasicAuthTlsConfig := &tls.Config{InsecureSkipVerify: true}
 
+	// this test is used to test the ws->http POC changes via manual execution with a local TP 4.0 gremlin server running on 8182
+	t.Run("Test client.submit()", func(t *testing.T) {
+		skipTestsIfNotEnabled(t, integrationTestSuiteName, testNoAuthEnable)
+
+		tlsConf := tls.Config{
+			InsecureSkipVerify: true,
+		}
+
+		client, err := NewClient(testNoAuthUrl,
+			//client, err := NewClient(noAuthSslUrl,
+			func(settings *ClientSettings) {
+				settings.TlsConfig = &tlsConf
+				settings.AuthInfo = testNoAuthAuthInfo
+				settings.WriteBufferSize = 1024
+				settings.EnableCompression = true
+				settings.TraversalSource = testServerModernGraphAlias
+			})
+		assert.Nil(t, err)
+		assert.NotNil(t, client)
+		defer client.Close()
+
+		// synchronous
+		for i := 0; i < 5; i++ {
+			submitCount(i, client, t)
+		}
+
+		// async
+		var wg sync.WaitGroup
+		for i := 0; i < 5; i++ {
+			wg.Add(1)
+			go func(i int) {
+				defer wg.Done()
+				submitCount(i, client, t)
+			}(i)
+		}
+		wg.Wait()
+
+		//
+		//g := cloneGraphTraversalSource(&Graph{}, NewGremlinLang(nil), nil)
+		//b := g.V().Count().Bytecode
+		//resultSet, err = client.submitBytecode(b)
+		//assert.Nil(t, err)
+		//assert.NotNil(t, resultSet)
+		//result, ok, err = resultSet.One()
+		//assert.Nil(t, err)
+		//assert.True(t, ok)
+		//assert.NotNil(t, result)
+	})
+
 	t.Run("Test client.submit() with concurrency", func(t *testing.T) {
 		skipTestsIfNotEnabled(t, integrationTestSuiteName, testNoAuthEnable)
 
@@ -514,42 +564,43 @@ func TestConnection(t *testing.T) {
 		resetGraph(t, g)
 	})
 
-	t.Run("Test DriverRemoteConnection GraphTraversal with Profile()", func(t *testing.T) {
-		skipTestsIfNotEnabled(t, integrationTestSuiteName, testNoAuthEnable)
-
-		// Initialize graph
-		g := initializeGraph(t, testNoAuthUrl, testNoAuthAuthInfo, testNoAuthTlsConfig)
-		defer g.remoteConnection.Close()
-
-		r, err := g.V().Has("name", "Lyndon").Values("foo").Profile().ToList()
-		assert.Nil(t, err)
-		assert.NotNil(t, r)
-		assert.Equal(t, 1, len(r))
-		metrics := r[0].Data.(*TraversalMetrics)
-		assert.NotNil(t, metrics)
-		assert.GreaterOrEqual(t, len(metrics.Metrics), 2)
-
-		resetGraph(t, g)
-	})
-
-	t.Run("Test DriverRemoteConnection GraphTraversal with GremlinType", func(t *testing.T) {
-		skipTestsIfNotEnabled(t, integrationTestSuiteName, testNoAuthEnable)
-
-		// Initialize graph
-		g := initializeGraph(t, testNoAuthUrl, testNoAuthAuthInfo, testNoAuthTlsConfig)
-		defer g.remoteConnection.Close()
-
-		prop := &GremlinType{"java.lang.Object"}
-		i := g.AddV("type_test").Property("data", prop).Iterate()
-		err := <-i
-		assert.Nil(t, err)
-
-		r, err := g.V().HasLabel("type_test").Values("data").Next()
-		assert.Nil(t, err)
-		assert.Equal(t, prop, r.Data.(*GremlinType))
-
-		resetGraph(t, g)
-	})
+	// TODO re-enable after profile() step is updated in server
+	//t.Run("Test DriverRemoteConnection GraphTraversal with Profile()", func(t *testing.T) {
+	//	skipTestsIfNotEnabled(t, integrationTestSuiteName, testNoAuthEnable)
+	//
+	//	// Initialize graph
+	//	g := initializeGraph(t, testNoAuthUrl, testNoAuthAuthInfo, testNoAuthTlsConfig)
+	//	defer g.remoteConnection.Close()
+	//
+	//	r, err := g.V().Has("name", "Lyndon").Values("foo").Profile().ToList()
+	//	assert.Nil(t, err)
+	//	assert.NotNil(t, r)
+	//	assert.Equal(t, 1, len(r))
+	//	metrics := r[0].Data.(*TraversalMetrics)
+	//	assert.NotNil(t, metrics)
+	//	assert.GreaterOrEqual(t, len(metrics.Metrics), 2)
+	//
+	//	resetGraph(t, g)
+	//})
+	// TODO pending removal
+	//t.Run("Test DriverRemoteConnection GraphTraversal with GremlinType", func(t *testing.T) {
+	//	skipTestsIfNotEnabled(t, integrationTestSuiteName, testNoAuthEnable)
+	//
+	//	// Initialize graph
+	//	g := initializeGraph(t, testNoAuthUrl, testNoAuthAuthInfo, testNoAuthTlsConfig)
+	//	defer g.remoteConnection.Close()
+	//
+	//	prop := &GremlinType{"java.lang.Object"}
+	//	i := g.AddV("type_test").Property("data", prop).Iterate()
+	//	err := <-i
+	//	assert.Nil(t, err)
+	//
+	//	r, err := g.V().HasLabel("type_test").Values("data").Next()
+	//	assert.Nil(t, err)
+	//	assert.Equal(t, prop, r.Data.(*GremlinType))
+	//
+	//	resetGraph(t, g)
+	//})
 
 	t.Run("Test DriverRemoteConnection GraphTraversal with BigDecimal", func(t *testing.T) {
 		skipTestsIfNotEnabled(t, integrationTestSuiteName, testNoAuthEnable)
@@ -563,31 +614,33 @@ func TestConnection(t *testing.T) {
 		err := <-i
 		assert.Nil(t, err)
 
-		r, err := g.V().HasLabel("type_test").Values("data").Next()
-		assert.Nil(t, err)
-		assert.Equal(t, prop, r.Data.(*BigDecimal))
+		// TODO revisit BigDecimal implementation
+		//r, err := g.V().HasLabel("type_test").Values("data").Next()
+		//assert.Nil(t, err)
+		//assert.Equal(t, prop, r.Data.(*BigDecimal))
 
 		resetGraph(t, g)
 	})
 
-	t.Run("Test DriverRemoteConnection GraphTraversal with byteBuffer", func(t *testing.T) {
-		skipTestsIfNotEnabled(t, integrationTestSuiteName, testNoAuthEnable)
-
-		// Initialize graph
-		g := initializeGraph(t, testNoAuthUrl, testNoAuthAuthInfo, testNoAuthTlsConfig)
-		defer g.remoteConnection.Close()
-
-		prop := &ByteBuffer{[]byte{byte(127), byte(255)}}
-		i := g.AddV("type_test").Property("data", prop).Iterate()
-		err := <-i
-		assert.Nil(t, err)
-
-		r, err := g.V().HasLabel("type_test").Values("data").Next()
-		assert.Nil(t, err)
-		assert.Equal(t, prop, r.Data)
-
-		resetGraph(t, g)
-	})
+	// TODO re-enable after sorting out message builder
+	//t.Run("Test DriverRemoteConnection GraphTraversal with byteBuffer", func(t *testing.T) {
+	//	skipTestsIfNotEnabled(t, integrationTestSuiteName, testNoAuthEnable)
+	//
+	//	// Initialize graph
+	//	g := initializeGraph(t, testNoAuthUrl, testNoAuthAuthInfo, testNoAuthTlsConfig)
+	//	defer g.remoteConnection.Close()
+	//
+	//	prop := &ByteBuffer{[]byte{byte(127), byte(255)}}
+	//	i := g.AddV("type_test").Property("data", prop).Iterate()
+	//	err := <-i
+	//	assert.Nil(t, err)
+	//
+	//	r, err := g.V().HasLabel("type_test").Values("data").Next()
+	//	assert.Nil(t, err)
+	//	assert.Equal(t, prop, r.Data)
+	//
+	//	resetGraph(t, g)
+	//})
 
 	t.Run("Test DriverRemoteConnection To Server Configured with Modern Graph", func(t *testing.T) {
 		skipTestsIfNotEnabled(t, integrationTestSuiteName, testNoAuthWithAliasEnable)
diff --git a/gremlin-go/driver/driverRemoteConnection.go b/gremlin-go/driver/driverRemoteConnection.go
index 86de97784a..d907a7fc34 100644
--- a/gremlin-go/driver/driverRemoteConnection.go
+++ b/gremlin-go/driver/driverRemoteConnection.go
@@ -100,14 +100,14 @@ func NewDriverRemoteConnection(
 
 	logHandler := newLogHandler(settings.Logger, settings.LogVerbosity, settings.Language)
 
-	httpProt := newGremlinClient(logHandler, url, connSettings)
+	httpProt := newHttpProtocol(logHandler, url, connSettings)
 
 	client := &Client{
 		url:                url,
 		traversalSource:    settings.TraversalSource,
 		logHandler:         logHandler,
 		connectionSettings: connSettings,
-		gremlinClient:      httpProt,
+		httpProtocol:       httpProt,
 	}
 
 	return &DriverRemoteConnection{client: client, isClosed: false, settings: settings}, nil
@@ -135,6 +135,15 @@ func (driver *DriverRemoteConnection) Submit(traversalString string) (ResultSet,
 	return driver.SubmitWithOptions(traversalString, *new(RequestOptions))
 }
 
+// submitGremlinLang sends a GremlinLang traversal to the server.
+// TODO test and update when connection is set up
+func (driver *DriverRemoteConnection) submitGremlinLang(gremlinLang *GremlinLang) (ResultSet, error) {
+	if driver.isClosed {
+		return nil, newError(err0203SubmitGremlinLangToClosedConnectionError)
+	}
+	return driver.client.submitGremlinLang(gremlinLang)
+}
+
 // submitBytecode sends a Bytecode traversal to the server.
 func (driver *DriverRemoteConnection) submitBytecode(bytecode *Bytecode) (ResultSet, error) {
 	if driver.isClosed {
diff --git a/gremlin-go/driver/error_codes.go b/gremlin-go/driver/error_codes.go
index 61b335ecb5..d1fd98af55 100644
--- a/gremlin-go/driver/error_codes.go
+++ b/gremlin-go/driver/error_codes.go
@@ -32,8 +32,13 @@ import (
 type errorCode string
 
 const (
+	// connection.go errors
+	err0101ConnectionCloseError       errorCode = "E0101_CONNECTION_CLOSE_ERROR"
+	err0102WriteConnectionClosedError errorCode = "E0102_CONNECTION_WRITE_CLOSED_ERROR"
+
 	// driverRemoteConnection.go errors
-	err0203SubmitBytecodeToClosedConnectionError errorCode = "E0203_DRIVER_REMOTE_CONNECTION_SUBMITBYTECODE_TO_CLOSED_CONNECTION_ERROR"
+	err0203SubmitGremlinLangToClosedConnectionError errorCode = "E0203_DRIVER_REMOTE_CONNECTION_SUBMITGREMLINLANG_TO_CLOSED_CONNECTION_ERROR"
+	err0203SubmitBytecodeToClosedConnectionError    errorCode = "E0203_DRIVER_REMOTE_CONNECTION_SUBMITBYTECODE_TO_CLOSED_CONNECTION_ERROR"
 
 	// graph.go errors
 	err0301GetPathObjectInvalidPathUnequalLengthsError errorCode = "E0301_GRAPH_GETPATHOBJECT_UNEQUAL_LABELS_OBJECTS_LENGTH_ERROR"
diff --git a/gremlin-go/driver/gValue.go b/gremlin-go/driver/gValue.go
new file mode 100644
index 0000000000..a1e5028129
--- /dev/null
+++ b/gremlin-go/driver/gValue.go
@@ -0,0 +1,61 @@
+/*
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements.  See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership.  The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License.  You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+*/
+
+package gremlingo
+
+import (
+	"fmt"
+	"strings"
+)
+
+// GValue is a variable or literal value that is used in a Traversal. It is composed of a key-value pair where the key
+// is the name given to the variable and the value is the object that the variable resolved to.
+type GValue interface {
+	Name() string
+	IsNil() bool
+	Value() interface{}
+}
+
+type gValue struct {
+	name  string
+	value interface{}
+}
+
+// NewGValue creates a new GValue to be used in traversals. The GValue name cannot begin with "_".
+func NewGValue(name string, value interface{}) GValue {
+	if strings.HasPrefix(name, "_") {
+		panic(fmt.Sprintf("invalid GValue name '%v'. Should not start with _.", name))
+	}
+	return &gValue{name, value}
+}
+
+// Name returns the name of the GValue.
+func (gv *gValue) Name() string {
+	return gv.name
+}
+
+// IsNil determines if the value held is of a nil value.
+func (gv *gValue) IsNil() bool {
+	return gv.value == nil
+}
+
+// Value returns the value held by the GValue.
+func (gv *gValue) Value() interface{} {
+	return gv.value
+}
diff --git a/gremlin-go/driver/gValue_test.go b/gremlin-go/driver/gValue_test.go
new file mode 100644
index 0000000000..cd4235278d
--- /dev/null
+++ b/gremlin-go/driver/gValue_test.go
@@ -0,0 +1,87 @@
+/*
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements.  See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership.  The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License.  You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+*/
+
+package gremlingo
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestGValue(t *testing.T) {
+
+	t.Run("test simple gValue", func(t *testing.T) {
+		gVal := NewGValue("intVal", 2)
+		assert.Equal(t, "intVal", gVal.Name())
+		assert.Equal(t, 2, gVal.Value())
+		assert.False(t, gVal.IsNil())
+	})
+
+	t.Run("test gValue allow parameter reuse with arrays", func(t *testing.T) {
+		g := NewGraphTraversalSource(nil, nil)
+		val := [3]int{1, 2, 3}
+		param := NewGValue("ids", val)
+		gl := g.Inject(param).V(param).GremlinLang
+		assert.Equal(t, "g.inject(ids).V(ids)", gl.GetGremlin())
+		assert.Equal(t, val, gl.parameters["ids"])
+	})
+
+	t.Run("test gValue allow parameter reuse with slices", func(t *testing.T) {
+		g := NewGraphTraversalSource(nil, nil)
+		val := []int{1, 2, 3}
+		param := NewGValue("ids", val)
+		gl := g.Inject(param).V(param).GremlinLang
+		assert.Equal(t, "g.inject(ids).V(ids)", gl.GetGremlin())
+		assert.Equal(t, val, gl.parameters["ids"])
+	})
+
+	t.Run("test gValue allow parameter reuse with maps", func(t *testing.T) {
+		g := NewGraphTraversalSource(nil, nil)
+		val := map[string]int{"foo": 1, "bar": 2}
+		param := NewGValue("ids", val)
+		gl := g.Inject(param).V(param).GremlinLang
+		assert.Equal(t, "g.inject(ids).V(ids)", gl.GetGremlin())
+		assert.Equal(t, val, gl.parameters["ids"])
+	})
+
+	t.Run("test gValue name not duplicated", func(t *testing.T) {
+		g := NewGraphTraversalSource(nil, nil)
+		param1 := NewGValue("ids", [2]int{1, 2})
+		param2 := NewGValue("ids", [2]int{2, 3})
+		assert.Panics(t, func() { g.Inject(param1).V(param2) }, "parameter with name ids already exists.")
+	})
+
+	t.Run("test invalid name that starts with _", func(t *testing.T) {
+		g := NewGraphTraversalSource(nil, nil)
+		assert.Panics(t, func() { g.Inject(NewGValue("_ids", [2]int{1, 2})) },
+			"invalid GValue name _1. Should not start with _.")
+	})
+
+	t.Run("test name is valid identifier", func(t *testing.T) {
+		g := NewGraphTraversalSource(nil, nil)
+		assert.Panics(t, func() { g.Inject(NewGValue("1a", [2]int{1, 2})) },
+			"invalid parameter name '1a'")
+	})
+
+	t.Run("test name is not a number", func(t *testing.T) {
+		g := NewGraphTraversalSource(nil, nil)
+		assert.Panics(t, func() { g.Inject(NewGValue("1", [2]int{1, 2})) },
+			"invalid parameter name '1'")
+	})
+}
diff --git a/gremlin-go/driver/graphBinary.go b/gremlin-go/driver/graphBinary.go
index 5d66ad454e..de3c071695 100644
--- a/gremlin-go/driver/graphBinary.go
+++ b/gremlin-go/driver/graphBinary.go
@@ -38,56 +38,35 @@ type dataType uint8
 
 // dataType defined as constants.
 const (
-	customType            dataType = 0x00
-	intType               dataType = 0x01
-	longType              dataType = 0x02
-	stringType            dataType = 0x03
-	dateType              dataType = 0x04
-	timestampType         dataType = 0x05
-	classType             dataType = 0x06
-	doubleType            dataType = 0x07
-	floatType             dataType = 0x08
-	listType              dataType = 0x09
-	mapType               dataType = 0x0a
-	setType               dataType = 0x0b
-	uuidType              dataType = 0x0c
-	edgeType              dataType = 0x0d
-	pathType              dataType = 0x0e
-	propertyType          dataType = 0x0f
-	vertexType            dataType = 0x11
-	vertexPropertyType    dataType = 0x12
-	barrierType           dataType = 0x13
-	bindingType           dataType = 0x14
-	cardinalityType       dataType = 0x16
-	bytecodeType          dataType = 0x15
-	columnType            dataType = 0x17
-	directionType         dataType = 0x18
-	operatorType          dataType = 0x19
-	orderType             dataType = 0x1a
-	pickType              dataType = 0x1b
-	popType               dataType = 0x1c
-	lambdaType            dataType = 0x1d
-	pType                 dataType = 0x1e
-	scopeType             dataType = 0x1f
-	tType                 dataType = 0x20
-	traverserType         dataType = 0x21
-	bigDecimalType        dataType = 0x22
-	bigIntegerType        dataType = 0x23
-	byteType              dataType = 0x24
-	byteBuffer            dataType = 0x25
-	shortType             dataType = 0x26
-	booleanType           dataType = 0x27
-	textPType             dataType = 0x28
-	traversalStrategyType dataType = 0x29
-	bulkSetType           dataType = 0x2a
-	mergeType             dataType = 0x2e
-	dtType                dataType = 0x2f
-	gTypeType             dataType = 0x30
-	metricsType           dataType = 0x2c
-	traversalMetricsType  dataType = 0x2d
-	durationType          dataType = 0x81
-	offsetDateTimeType    dataType = 0x88
-	nullType              dataType = 0xFE
+	customType         dataType = 0x00
+	intType            dataType = 0x01
+	longType           dataType = 0x02
+	stringType         dataType = 0x03
+	datetimeType       dataType = 0x04
+	doubleType         dataType = 0x07
+	floatType          dataType = 0x08
+	listType           dataType = 0x09
+	mapType            dataType = 0x0a
+	setType            dataType = 0x0b
+	uuidType           dataType = 0x0c
+	edgeType           dataType = 0x0d
+	pathType           dataType = 0x0e
+	propertyType       dataType = 0x0f
+	vertexType         dataType = 0x11
+	vertexPropertyType dataType = 0x12
+	directionType      dataType = 0x18
+	tType              dataType = 0x20
+	bigDecimalType     dataType = 0x22
+	bigIntegerType     dataType = 0x23
+	byteType           dataType = 0x24
+	byteBuffer         dataType = 0x25
+	shortType          dataType = 0x26
+	booleanType        dataType = 0x27
+	mergeType          dataType = 0x2e
+	gTypeType          dataType = 0x30
+	durationType       dataType = 0x81
+	markerType         dataType = 0xfd
+	nullType           dataType = 0xFE
 )
 
 var nullBytes = []byte{nullType.getCodeByte(), 0x01}
@@ -193,72 +172,6 @@ func mapWriter(value interface{}, buffer *bytes.Buffer, typeSerializer *graphBin
 	return buffer.Bytes(), nil
 }
 
-func instructionWriter(instructions []instruction, buffer *bytes.Buffer, typeSerializer *graphBinaryTypeSerializer) error {
-	// Write {steps_length}, i.e number of steps.
-	err := binary.Write(buffer, binary.BigEndian, int32(len(instructions)))
-	if err != nil {
-		return err
-	}
-
-	// Write {step_0} to {step_n}.
-	for _, instruction := range instructions {
-		// Write {name} of {step_i}.
-		// Note: {name} follows string writing, therefore write string length followed by actual string.
-		_, err = typeSerializer.writeValue(instruction.operator, buffer, false)
-		if err != nil {
-			return err
-		}
-
-		// Write {values_length} of {step_i}.
-		err = binary.Write(buffer, binary.BigEndian, int32(len(instruction.arguments)))
-		if err != nil {
-			return err
-		}
-
-		// Write {values_0} to {values_n}.
-		for _, argument := range instruction.arguments {
-			_, err = typeSerializer.write(argument, buffer)
-			if err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
-// Format: {steps_length}{step_0}…{step_n}{sources_length}{source_0}…{source_n}
-// Where:
-//
-//			{steps_length} is an Int value describing the amount of steps.
-//			{step_i} is composed of {name}{values_length}{value_0}…{value_n}, where:
-//	     {name} is a String. This is also known as the operator.
-//			{values_length} is an Int describing the amount values.
-//			{value_i} is a fully qualified typed value composed of {type_code}{type_info}{value_flag}{value} describing the step argument.
-func bytecodeWriter(value interface{}, buffer *bytes.Buffer, typeSerializer *graphBinaryTypeSerializer) ([]byte, error) {
-	var bc Bytecode
-	switch typedVal := value.(type) {
-	case *GraphTraversal:
-		bc = *typedVal.Bytecode
-	case Bytecode:
-		bc = typedVal
-	case *Bytecode:
-		bc = *typedVal
-	default:
-		return nil, newError(err0402BytecodeWriterError)
-	}
-
-	// Write {steps_length} and {step_0} through {step_n}, then {sources_length} and {source_0} through {source_n}
-	err := instructionWriter(bc.stepInstructions, buffer, typeSerializer)
-	if err != nil {
-		return nil, err
-	}
-	err = instructionWriter(bc.sourceInstructions, buffer, typeSerializer)
-	if err != nil {
-		return nil, err
-	}
-	return buffer.Bytes(), nil
-}
-
 func stringWriter(value interface{}, buffer *bytes.Buffer, _ *graphBinaryTypeSerializer) ([]byte, error) {
 	err := binary.Write(buffer, binary.BigEndian, int32(len(value.(string))))
 	if err != nil {
@@ -368,16 +281,6 @@ func bigDecimalWriter(value interface{}, buffer *bytes.Buffer, typeSerializer *g
 	return bigIntWriter(v.UnscaledValue, buffer, typeSerializer)
 }
 
-func classWriter(value interface{}, buffer *bytes.Buffer, typeSerializer *graphBinaryTypeSerializer) ([]byte, error) {
-	var v GremlinType
-	if reflect.TypeOf(value).Kind() == reflect.Ptr {
-		v = *(value.(*GremlinType))
-	} else {
-		v = value.(GremlinType)
-	}
-	return stringWriter(v.Fqcn, buffer, typeSerializer)
-}
-
 // Format: {Id}{Label}{properties}
 func vertexWriter(value interface{}, buffer *bytes.Buffer, typeSerializer *graphBinaryTypeSerializer) ([]byte, error) {
 	v := value.(*Vertex)
@@ -387,7 +290,7 @@ func vertexWriter(value interface{}, buffer *bytes.Buffer, typeSerializer *graph
 	}
 
 	// Not fully qualified.
-	_, err = typeSerializer.writeValue(v.Label, buffer, false)
+	_, err = typeSerializer.writeValue([1]string{v.Label}, buffer, false)
 	if err != nil {
 		return nil, err
 	}
@@ -405,7 +308,7 @@ func edgeWriter(value interface{}, buffer *bytes.Buffer, typeSerializer *graphBi
 	}
 
 	// Not fully qualified
-	_, err = typeSerializer.writeValue(e.Label, buffer, false)
+	_, err = typeSerializer.writeValue([1]string{e.Label}, buffer, false)
 	if err != nil {
 		return nil, err
 	}
@@ -467,7 +370,7 @@ func vertexPropertyWriter(value interface{}, buffer *bytes.Buffer, typeSerialize
 	}
 
 	// Not fully qualified.
-	_, err = typeSerializer.writeValue(vp.Label, buffer, false)
+	_, err = typeSerializer.writeValue([1]string{vp.Label}, buffer, false)
 	if err != nil {
 		return nil, err
 	}
@@ -503,21 +406,11 @@ func setWriter(value interface{}, buffer *bytes.Buffer, typeSerializer *graphBin
 }
 
 func timeWriter(value interface{}, buffer *bytes.Buffer, _ *graphBinaryTypeSerializer) ([]byte, error) {
-	t := value.(time.Time)
-	err := binary.Write(buffer, binary.BigEndian, t.UnixMilli())
-	if err != nil {
-		return nil, err
-	}
-	return buffer.Bytes(), nil
-}
-
-func offsetDateTimeWriter(value interface{}, buffer *bytes.Buffer, _ *graphBinaryTypeSerializer) ([]byte, error) {
 	t := value.(time.Time)
 	err := binary.Write(buffer, binary.BigEndian, int32(t.Year()))
 	if err != nil {
 		return nil, err
 	}
-
 	err = binary.Write(buffer, binary.BigEndian, byte(t.Month()))
 	if err != nil {
 		return nil, err
@@ -527,11 +420,11 @@ func offsetDateTimeWriter(value interface{}, buffer *bytes.Buffer, _ *graphBinar
 		return nil, err
 	}
 	// construct time of day in nanoseconds
-	h := int64(t.Hour())
-	m := int64(t.Minute())
-	s := int64(t.Second())
-	ns := (h * 60 * 60 * 1e9) + (m * 60 * 1e9) + (s * 1e9) + int64(t.Nanosecond())
-	err = binary.Write(buffer, binary.BigEndian, ns)
+	h := t.Hour()
+	m := t.Minute()
+	s := t.Second()
+	ns := (h * 60 * 60 * 1e9) + (m * 60 * 1e9) + (s * 1e9) + t.Nanosecond()
+	err = binary.Write(buffer, binary.BigEndian, int64(ns))
 	if err != nil {
 		return nil, err
 	}
@@ -540,7 +433,6 @@ func offsetDateTimeWriter(value interface{}, buffer *bytes.Buffer, _ *graphBinar
 	if err != nil {
 		return nil, err
 	}
-
 	return buffer.Bytes(), nil
 }
 
@@ -559,40 +451,15 @@ func durationWriter(value interface{}, buffer *bytes.Buffer, _ *graphBinaryTypeS
 	return buffer.Bytes(), nil
 }
 
-const (
-	valueFlagNull byte = 1
-	valueFlagNone byte = 0
-)
-
 func enumWriter(value interface{}, buffer *bytes.Buffer, typeSerializer *graphBinaryTypeSerializer) ([]byte, error) {
 	_, err := typeSerializer.write(reflect.ValueOf(value).String(), buffer)
 	return buffer.Bytes(), err
 }
 
-// Format: {language}{script}{arguments_length}
-func lambdaWriter(value interface{}, buffer *bytes.Buffer, typeSerializer *graphBinaryTypeSerializer) ([]byte, error) {
-	lambda := value.(*Lambda)
-	if lambda.Language == "" {
-		lambda.Language = "gremlin-groovy"
-	}
-	_, err := typeSerializer.writeValue(lambda.Language, buffer, false)
-	if err != nil {
-		return nil, err
-	}
-
-	_, err = typeSerializer.writeValue(lambda.Script, buffer, false)
-	if err != nil {
-		return nil, err
-	}
-
-	// It's hard to know how many parameters there are without extensive string parsing.
-	// Instead, we can set -1 which means unknown.
-	err = binary.Write(buffer, binary.BigEndian, int32(-1))
-	if err != nil {
-		return nil, err
-	}
-
-	return buffer.Bytes(), nil
+func markerWriter(value interface{}, buffer *bytes.Buffer, _ *graphBinaryTypeSerializer) ([]byte, error) {
+	m := value.(Marker)
+	err := binary.Write(buffer, binary.BigEndian, m.GetValue())
+	return buffer.Bytes(), err
 }
 
 // Format: {strategy_class}{configuration}
@@ -607,84 +474,13 @@ func traversalStrategyWriter(value interface{}, buffer *bytes.Buffer, typeSerial
 	return mapWriter(ts.configuration, buffer, typeSerializer)
 }
 
-func pWriter(value interface{}, buffer *bytes.Buffer, typeSerializer *graphBinaryTypeSerializer) ([]byte, error) {
-	var v p
-	if reflect.TypeOf(value).Kind() == reflect.Ptr {
-		v = *(value.(*p))
-	} else {
-		v = value.(p)
-	}
-	_, err := typeSerializer.writeValue(v.operator, buffer, false)
-	if err != nil {
-		return nil, err
-	}
-
-	err = binary.Write(buffer, binary.BigEndian, int32(len(v.values)))
-	if err != nil {
-		return nil, err
-	}
-
-	for _, pValue := range v.values {
-		_, err := typeSerializer.write(pValue, buffer)
-		if err != nil {
-			return nil, err
-		}
-	}
-	return buffer.Bytes(), err
-}
-
-func textPWriter(value interface{}, buffer *bytes.Buffer, typeSerializer *graphBinaryTypeSerializer) ([]byte, error) {
-	var v textP
-	if reflect.TypeOf(value).Kind() == reflect.Ptr {
-		v = *(value.(*textP))
-	} else {
-		v = value.(textP)
-	}
-	_, err := typeSerializer.writeValue(v.operator, buffer, false)
-	if err != nil {
-		return nil, err
-	}
-
-	err = binary.Write(buffer, binary.BigEndian, int32(len(v.values)))
-	if err != nil {
-		return nil, err
-	}
-
-	for _, pValue := range v.values {
-		_, err := typeSerializer.write(pValue, buffer)
-		if err != nil {
-			return nil, err
-		}
-	}
-	return buffer.Bytes(), err
-}
-
-// Format: {key}{value}
-func bindingWriter(value interface{}, buffer *bytes.Buffer, typeSerializer *graphBinaryTypeSerializer) ([]byte, error) {
-	var v Binding
-	if reflect.TypeOf(value).Kind() == reflect.Ptr {
-		v = *(value.(*Binding))
-	} else {
-		v = value.(Binding)
-	}
-
-	// Not fully qualified.
-	_, err := typeSerializer.writeValue(v.Key, buffer, false)
-	if err != nil {
-		return nil, err
-	}
-
-	_, err = typeSerializer.write(v.Value, buffer)
-	if err != nil {
-		return nil, err
-	}
-	return buffer.Bytes(), nil
-}
+const (
+	valueFlagNull byte = 1
+	valueFlagNone byte = 0
+)
 
 func (serializer *graphBinaryTypeSerializer) getType(val interface{}) (dataType, error) {
 	switch val.(type) {
-	case *Bytecode, Bytecode, *GraphTraversal:
-		return bytecodeType, nil
 	case string:
 		return stringType, nil
 	case uint, uint64, *big.Int:
@@ -713,58 +509,24 @@ func (serializer *graphBinaryTypeSerializer) getType(val interface{}) (dataType,
 		return propertyType, nil
 	case *VertexProperty:
 		return vertexPropertyType, nil
-	case *Lambda:
-		return lambdaType, nil
-	case *traversalStrategy:
-		return traversalStrategyType, nil
 	case *Path:
 		return pathType, nil
 	case Set:
 		return setType, nil
 	case time.Time:
-		return offsetDateTimeType, nil // default serialization of Time will become OffsetDateTime
+		return datetimeType, nil
 	case time.Duration:
 		return durationType, nil
-	case cardinality:
-		return cardinalityType, nil
-	case column:
-		return columnType, nil
 	case direction:
 		return directionType, nil
-	case operator:
-		return operatorType, nil
-	case order:
-		return orderType, nil
-	case pick:
-		return pickType, nil
-	case pop:
-		return popType, nil
 	case t:
 		return tType, nil
-	case barrier:
-		return barrierType, nil
-	case scope:
-		return scopeType, nil
 	case merge:
 		return mergeType, nil
-	case dt:
-		return dtType, nil
 	case gType:
 		return gTypeType, nil
-	case p, Predicate:
-		return pType, nil
-	case textP, TextPredicate:
-		return textPType, nil
-	case *Binding, Binding:
-		return bindingType, nil
 	case *BigDecimal, BigDecimal:
 		return bigDecimalType, nil
-	case *GremlinType, GremlinType:
-		return classType, nil
-	case *Metrics, Metrics:
-		return metricsType, nil
-	case *TraversalMetrics, TraversalMetrics:
-		return traversalMetricsType, nil
 	case *ByteBuffer, ByteBuffer:
 		return byteBuffer, nil
 	default:
@@ -963,8 +725,6 @@ func getDefaultValue(dataType dataType) interface{} {
 	switch dataType {
 	case intType, bigIntegerType, longType, shortType, byteType, booleanType, floatType, doubleType:
 		return 0
-	case traverserType, stringType:
-		return ""
 	case uuidType:
 		return uuid.Nil
 	case vertexType:
@@ -979,7 +739,7 @@ func getDefaultValue(dataType dataType) interface{} {
 		return Path{}
 	case setType:
 		return SimpleSet{}
-	case dateType, timestampType:
+	case datetimeType:
 		return time.Time{}
 	case durationType:
 		return time.Duration(0)
@@ -989,15 +749,28 @@ func getDefaultValue(dataType dataType) interface{} {
 }
 
 // Composite
-func readList(data *[]byte, i *int) (interface{}, error) {
+func readList(data *[]byte, i *int, flag byte) (interface{}, error) {
 	sz := readIntSafe(data, i)
 	var valList []interface{}
-	for j := int32(0); j < sz; j++ {
-		val, err := readFullyQualifiedNullable(data, i, true)
-		if err != nil {
-			return nil, err
+	if flag == 0x02 {
+		for j := int32(0); j < sz; j++ {
+			val, err := readFullyQualifiedNullable(data, i, true)
+			if err != nil {
+				return nil, err
+			}
+			bulk := readIntSafe(data, i)
+			for k := int32(0); k < bulk; k++ {
+				valList = append(valList, val)
+			}
+		}
+	} else {
+		for j := int32(0); j < sz; j++ {
+			val, err := readFullyQualifiedNullable(data, i, true)
+			if err != nil {
+				return nil, err
+			}
+			valList = append(valList, val)
 		}
-		valList = append(valList, val)
 	}
 	return valList, nil
 }
@@ -1064,8 +837,8 @@ func readMapUnqualified(data *[]byte, i *int) (interface{}, error) {
 	return mapData, nil
 }
 
-func readSet(data *[]byte, i *int) (interface{}, error) {
-	list, err := readList(data, i)
+func readSet(data *[]byte, i *int, flag byte) (interface{}, error) {
+	list, err := readList(data, i, flag)
 	if err != nil {
 		return nil, err
 	}
@@ -1078,10 +851,6 @@ func readUuid(data *[]byte, i *int) (interface{}, error) {
 }
 
 func timeReader(data *[]byte, i *int) (interface{}, error) {
-	return time.UnixMilli(readLongSafe(data, i)), nil
-}
-
-func offsetDateTimeReader(data *[]byte, i *int) (interface{}, error) {
 	year := readIntSafe(data, i)
 	month := readByteSafe(data, i)
 	day := readByteSafe(data, i)
@@ -1137,11 +906,11 @@ func vertexReaderReadingProperties(data *[]byte, i *int, readProperties bool) (i
 	if err != nil {
 		return nil, err
 	}
-	label, err := readUnqualified(data, i, stringType, false)
+	label, err := readList(data, i, 0)
 	if err != nil {
 		return nil, err
 	}
-	v.Label = label.(string)
+	v.Label = label.([]interface{})[0].(string)
 	if readProperties {
 		props, err := readFullyQualifiedNullable(data, i, true)
 		if err != nil {
@@ -1164,11 +933,11 @@ func edgeReader(data *[]byte, i *int) (interface{}, error) {
 	if err != nil {
 		return nil, err
 	}
-	label, err := readUnqualified(data, i, stringType, false)
+	label, err := readUnqualified(data, i, listType, false)
 	if err != nil {
 		return nil, err
 	}
-	e.Label = label.(string)
+	e.Label = label.([]interface{})[0].(string)
 	v, err := vertexReaderReadingProperties(data, i, false)
 	if err != nil {
 		return nil, err
@@ -1216,11 +985,11 @@ func vertexPropertyReader(data *[]byte, i *int) (interface{}, error) {
 	if err != nil {
 		return nil, err
 	}
-	label, err := readUnqualified(data, i, stringType, false)
+	label, err := readList(data, i, 0)
 	if err != nil {
 		return nil, err
 	}
-	vp.Label = label.(string)
+	vp.Label = label.([]interface{})[0].(string)
 	vp.Value, err = readFullyQualifiedNullable(data, i, true)
 	if err != nil {
 		return nil, err
@@ -1260,35 +1029,6 @@ func pathReader(data *[]byte, i *int) (interface{}, error) {
 	return path, err
 }
 
-// {bulk int}{fully qualified value}
-func traverserReader(data *[]byte, i *int) (interface{}, error) {
-	var err error
-	traverser := new(Traverser)
-	traverser.bulk = readLongSafe(data, i)
-	traverser.value, err = readFullyQualifiedNullable(data, i, true)
-	if err != nil {
-		return nil, err
-	}
-	return traverser, nil
-}
-
-// {int32 length}{fully qualified item_0}{int64 repetition_0}...{fully qualified item_n}{int64 repetition_n}
-func bulkSetReader(data *[]byte, i *int) (interface{}, error) {
-	sz := int(readIntSafe(data, i))
-	var valList []interface{}
-	for j := 0; j < sz; j++ {
-		val, err := readFullyQualifiedNullable(data, i, true)
-		if err != nil {
-			return nil, err
-		}
-		rep := readLongSafe(data, i)
-		for k := 0; k < int(rep); k++ {
-			valList = append(valList, val)
-		}
-	}
-	return valList, nil
-}
-
 // {type code (always string so ignore)}{nil code (always false so ignore)}{int32 size}{string enum}
 func enumReader(data *[]byte, i *int) (interface{}, error) {
 	typeCode := readDataType(data, i)
@@ -1299,113 +1039,14 @@ func enumReader(data *[]byte, i *int) (interface{}, error) {
 	return readString(data, i)
 }
 
-// {unqualified key}{fully qualified value}
-func bindingReader(data *[]byte, i *int) (interface{}, error) {
-	b := new(Binding)
-	val, err := readUnqualified(data, i, stringType, false)
+func markerReader(data *[]byte, i *int) (interface{}, error) {
+	m, err := Of(readByteSafe(data, i))
 	if err != nil {
 		return nil, err
 	}
-	b.Key = val.(string)
-
-	b.Value, err = readFullyQualifiedNullable(data, i, true)
-	if err != nil {
-		return nil, err
-	}
-	return b, nil
-}
-
-// {id}{name}{duration}{counts}{annotations}{nested_metrics}
-func metricsReader(data *[]byte, i *int) (interface{}, error) {
-	metrics := new(Metrics)
-	val, err := readUnqualified(data, i, stringType, false)
-	if err != nil {
-		return nil, err
-	}
-	metrics.Id = val.(string)
-
-	val, err = readUnqualified(data, i, stringType, false)
-	if err != nil {
-		return nil, err
-	}
-	metrics.Name = val.(string)
-
-	dur, err := readLong(data, i)
-	if err != nil {
-		return nil, err
-	}
-	metrics.Duration = dur.(int64)
-
-	counts, err := readMap(data, i)
-	cmap := counts.(map[interface{}]interface{})
-	if err != nil {
-		return nil, err
-	}
-	metrics.Counts = make(map[string]int64, len(cmap))
-	for k := range cmap {
-		metrics.Counts[k.(string)] = cmap[k].(int64)
-	}
-
-	annotations, err := readMap(data, i)
-	if err != nil {
-		return nil, err
-	}
-	amap := annotations.(map[interface{}]interface{})
-	if err != nil {
-		return nil, err
-	}
-	metrics.Annotations = make(map[string]interface{}, len(amap))
-	for k := range amap {
-		metrics.Annotations[k.(string)] = amap[k]
-	}
-
-	nested, err := readList(data, i)
-	if err != nil {
-		return nil, err
-	}
-	list := nested.([]interface{})
-	metrics.NestedMetrics = make([]Metrics, len(list))
-	for i, metric := range list {
-		metrics.NestedMetrics[i] = metric.(Metrics)
-	}
-
-	return metrics, nil
-}
-
-// {id}{name}{duration}{counts}{annotations}{nested_metrics}
-func traversalMetricsReader(data *[]byte, i *int) (interface{}, error) {
-	m := new(TraversalMetrics)
-	dur, err := readLong(data, i)
-	if err != nil {
-		return nil, err
-	}
-	m.Duration = dur.(int64)
-
-	nested, err := readList(data, i)
-	if err != nil {
-		return nil, err
-	}
-	list := nested.([]interface{})
-	m.Metrics = make([]Metrics, len(list))
-	for i, metric := range list {
-		m.Metrics[i] = *metric.(*Metrics)
-	}
-
 	return m, nil
 }
 
-// Format: A String containing the fqcn.
-func readClass(data *[]byte, i *int) (interface{}, error) {
-	gremlinType := new(GremlinType)
-	str, err := readString(data, i)
-	if err != nil {
-		return nil, err
-	}
-	gremlinType.Fqcn = str.(string)
-
-	return gremlinType, nil
-}
-
 func readUnqualified(data *[]byte, i *int, dataTyp dataType, nullable bool) (interface{}, error) {
 	if nullable && readByteSafe(data, i) == valueFlagNull {
 		return getDefaultValue(dataTyp), nil
@@ -1425,9 +1066,16 @@ func readFullyQualifiedNullable(data *[]byte, i *int, nullable bool) (interface{
 		}
 		return nil, nil
 	} else if nullable {
-		if readByteSafe(data, i) == valueFlagNull {
+		flag := readByteSafe(data, i)
+		if flag == valueFlagNull {
 			return getDefaultValue(dataTyp), nil
 		}
+		if dataTyp == listType {
+			return readList(data, i, flag)
+		}
+		if dataTyp == setType {
+			return readSet(data, i, flag)
+		}
 	}
 	deserializer, ok := deserializers[dataTyp]
 	if !ok {
diff --git a/gremlin-go/driver/graphBinary_test.go b/gremlin-go/driver/graphBinary_test.go
index c47b327db4..f974bef652 100644
--- a/gremlin-go/driver/graphBinary_test.go
+++ b/gremlin-go/driver/graphBinary_test.go
@@ -83,16 +83,6 @@ func TestGraphBinaryV1(t *testing.T) {
 			assert.Nil(t, err)
 			assert.Equal(t, str, res)
 		})
-		t.Run("read-write GremlinType", func(t *testing.T) {
-			pos := 0
-			var buffer bytes.Buffer
-			source := &GremlinType{"test fqcn"}
-			buf, err := classWriter(source, &buffer, nil)
-			assert.Nil(t, err)
-			res, err := readClass(&buf, &pos)
-			assert.Nil(t, err)
-			assert.Equal(t, source, res)
-		})
 		t.Run("read-write bool", func(t *testing.T) {
 			pos := 0
 			var buffer bytes.Buffer
@@ -198,7 +188,7 @@ func TestGraphBinaryV1(t *testing.T) {
 			source := []interface{}{int32(111), "str"}
 			buf, err := listWriter(source, &buffer, nil)
 			assert.Nil(t, err)
-			res, err := readList(&buf, &pos)
+			res, err := readList(&buf, &pos, 0x00)
 			assert.Nil(t, err)
 			assert.Equal(t, source, res)
 		})
@@ -218,7 +208,7 @@ func TestGraphBinaryV1(t *testing.T) {
 			source := NewSimpleSet(int32(111), "str")
 			buf, err := setWriter(source, &buffer, nil)
 			assert.Nil(t, err)
-			res, err := readSet(&buf, &pos)
+			res, err := readSet(&buf, &pos, 0x00)
 			assert.Nil(t, err)
 			assert.Equal(t, source, res)
 		})
@@ -310,7 +300,8 @@ func TestGraphBinaryV1(t *testing.T) {
 			assert.Nil(t, err)
 			res, err := timeReader(&buf, &pos)
 			assert.Nil(t, err)
-			assert.Equal(t, source, res)
+			// ISO format
+			assert.Equal(t, source.Format(time.RFC3339Nano), res.(time.Time).Format(time.RFC3339Nano))
 		})
 		t.Run("read-write local datetime", func(t *testing.T) {
 			pos := 0
@@ -356,4 +347,16 @@ func TestGraphBinaryV1(t *testing.T) {
 			assert.Equal(t, newError(err0703ReadMapNonStringKeyError, intType), err)
 		})
 	})
+
+	t.Run("read-write marker", func(t *testing.T) {
+		pos := 0
+		var buffer bytes.Buffer
+		source := EndOfStream()
+		buf, err := markerWriter(source, &buffer, nil)
+		assert.Nil(t, err)
+		res, err := markerReader(&buf, &pos)
+		assert.Nil(t, err)
+		assert.Equal(t, source, res)
+	})
+
 }
diff --git a/gremlin-go/driver/graphTraversal.go b/gremlin-go/driver/graphTraversal.go
index dc136bef82..abca84b18f 100644
--- a/gremlin-go/driver/graphTraversal.go
+++ b/gremlin-go/driver/graphTraversal.go
@@ -36,12 +36,15 @@ type GraphTraversal struct {
 
 // NewGraphTraversal make a new GraphTraversal.
 // why is this taking a non exported field as an exported function - remove or replace?
-func NewGraphTraversal(graph *Graph, bytecode *Bytecode, remote *DriverRemoteConnection) *GraphTraversal {
+func NewGraphTraversal(graph *Graph, gremlinLang *GremlinLang, remote *DriverRemoteConnection) *GraphTraversal {
+	if gremlinLang == nil {
+		gremlinLang = NewGremlinLang(nil)
+	}
 	gt := &GraphTraversal{
 		Traversal: &Traversal{
-			graph:    graph,
-			Bytecode: bytecode,
-			remote:   remote,
+			graph:       graph,
+			GremlinLang: gremlinLang,
+			remote:      remote,
 		},
 	}
 	return gt
@@ -49,7 +52,7 @@ func NewGraphTraversal(graph *Graph, bytecode *Bytecode, remote *DriverRemoteCon
 
 // Clone make a copy of a traversal that is reset for iteration.
 func (g *GraphTraversal) Clone() *GraphTraversal {
-	return NewGraphTraversal(g.graph, NewBytecode(g.Bytecode), g.remote)
+	return NewGraphTraversal(g.graph, NewGremlinLang(g.GremlinLang), g.remote)
 }
 
 // V adds the v step to the GraphTraversal.
@@ -59,55 +62,55 @@ func (g *GraphTraversal) V(args ...interface{}) *GraphTraversal {
 			args[i] = v.Id
 		}
 	}
-	g.Bytecode.AddStep("V", args...)
+	g.GremlinLang.AddStep("V", args...)
 	return g
 }
 
 // E adds the e step to the GraphTraversal.
 func (g *GraphTraversal) E(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("E", args...)
+	g.GremlinLang.AddStep("E", args...)
 	return g
 }
 
 // AddE adds the addE step to the GraphTraversal.
 func (g *GraphTraversal) AddE(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("addE", args...)
+	g.GremlinLang.AddStep("addE", args...)
 	return g
 }
 
 // AddV adds the addV step to the GraphTraversal.
 func (g *GraphTraversal) AddV(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("addV", args...)
+	g.GremlinLang.AddStep("addV", args...)
 	return g
 }
 
 // Aggregate adds the aggregate step to the GraphTraversal.
 func (g *GraphTraversal) Aggregate(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("aggregate", args...)
+	g.GremlinLang.AddStep("aggregate", args...)
 	return g
 }
 
 // All adds the all step to the GraphTraversal.
 func (g *GraphTraversal) All(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("all", args...)
+	g.GremlinLang.AddStep("all", args...)
 	return g
 }
 
 // And adds the and step to the GraphTraversal.
 func (g *GraphTraversal) And(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("and", args...)
+	g.GremlinLang.AddStep("and", args...)
 	return g
 }
 
 // Any adds the any step to the GraphTraversal.
 func (g *GraphTraversal) Any(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("any", args...)
+	g.GremlinLang.AddStep("any", args...)
 	return g
 }
 
 // As adds the as step to the GraphTraversal.
 func (g *GraphTraversal) As(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("as", args...)
+	g.GremlinLang.AddStep("as", args...)
 	return g
 }
 
@@ -119,7 +122,7 @@ func (g *GraphTraversal) AsBool(args ...interface{}) *GraphTraversal {
 
 // AsDate adds the asDate step to the GraphTraversal.
 func (g *GraphTraversal) AsDate(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("asDate", args...)
+	g.GremlinLang.AddStep("asDate", args...)
 	return g
 }
 
@@ -131,207 +134,207 @@ func (g *GraphTraversal) AsNumber(args ...interface{}) *GraphTraversal {
 
 // AsString adds the asString step to the GraphTraversal.
 func (g *GraphTraversal) AsString(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("asString", args...)
+	g.GremlinLang.AddStep("asString", args...)
 	return g
 }
 
 // Barrier adds the barrier step to the GraphTraversal.
 func (g *GraphTraversal) Barrier(args ...interface{}) *GraphTraversal {
 	// Force int32 serialization for valid number values for server compatibility
-	g.Bytecode.AddStep("barrier", int32Args(args)...)
+	g.GremlinLang.AddStep("barrier", int32Args(args)...)
 	return g
 }
 
 // Both adds the both step to the GraphTraversal.
 func (g *GraphTraversal) Both(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("both", args...)
+	g.GremlinLang.AddStep("both", args...)
 	return g
 }
 
 // BothE adds the bothE step to the GraphTraversal.
 func (g *GraphTraversal) BothE(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("bothE", args...)
+	g.GremlinLang.AddStep("bothE", args...)
 	return g
 }
 
 // BothV adds the bothV step to the GraphTraversal.
 func (g *GraphTraversal) BothV(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("bothV", args...)
+	g.GremlinLang.AddStep("bothV", args...)
 	return g
 }
 
 // Branch adds the branch step to the GraphTraversal.
 func (g *GraphTraversal) Branch(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("branch", args...)
+	g.GremlinLang.AddStep("branch", args...)
 	return g
 }
 
 // By adds the by step to the GraphTraversal.
 func (g *GraphTraversal) By(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("by", args...)
+	g.GremlinLang.AddStep("by", args...)
 	return g
 }
 
 // Call adds the call step to the GraphTraversal.
 func (g *GraphTraversal) Call(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("call", args...)
+	g.GremlinLang.AddStep("call", args...)
 	return g
 }
 
 // Cap adds the cap step to the GraphTraversal.
 func (g *GraphTraversal) Cap(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("cap", args...)
+	g.GremlinLang.AddStep("cap", args...)
 	return g
 }
 
 // Choose adds the choose step to the GraphTraversal.
 func (g *GraphTraversal) Choose(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("choose", args...)
+	g.GremlinLang.AddStep("choose", args...)
 	return g
 }
 
 // Coalesce adds the coalesce step to the GraphTraversal.
 func (g *GraphTraversal) Coalesce(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("coalesce", args...)
+	g.GremlinLang.AddStep("coalesce", args...)
 	return g
 }
 
 // Coin adds the coint step to the GraphTraversal.
 func (g *GraphTraversal) Coin(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("coin", args...)
+	g.GremlinLang.AddStep("coin", args...)
 	return g
 }
 
 // Combine adds the combine step to the GraphTraversal.
 func (g *GraphTraversal) Combine(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("combine", args...)
+	g.GremlinLang.AddStep("combine", args...)
 	return g
 }
 
 // Concat adds the concat step to the GraphTraversal.
 func (g *GraphTraversal) Concat(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("concat", args...)
+	g.GremlinLang.AddStep("concat", args...)
 	return g
 }
 
 // Conjoin adds the conjoin step to the GraphTraversal.
 func (g *GraphTraversal) Conjoin(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("conjoin", args...)
+	g.GremlinLang.AddStep("conjoin", args...)
 	return g
 }
 
 // ConnectedComponent adds the connectedComponent step to the GraphTraversal.
 func (g *GraphTraversal) ConnectedComponent(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("connectedComponent", args...)
+	g.GremlinLang.AddStep("connectedComponent", args...)
 	return g
 }
 
 // Constant adds the constant step to the GraphTraversal.
 func (g *GraphTraversal) Constant(args ...interface{}) *GraphTraversal {
 	// Force int32 serialization for valid number values for server compatibility
-	g.Bytecode.AddStep("constant", int32Args(args)...)
+	g.GremlinLang.AddStep("constant", int32Args(args)...)
 	return g
 }
 
 // Count adds the count step to the GraphTraversal.
 func (g *GraphTraversal) Count(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("count", args...)
+	g.GremlinLang.AddStep("count", args...)
 	return g
 }
 
 // CyclicPath adds the cyclicPath step to the GraphTraversal.
 func (g *GraphTraversal) CyclicPath(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("cyclicPath", args...)
+	g.GremlinLang.AddStep("cyclicPath", args...)
 	return g
 }
 
 // DateAdd adds the dateAdd step to the GraphTraversal.
 func (g *GraphTraversal) DateAdd(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("dateAdd", int32Args(args)...)
+	g.GremlinLang.AddStep("dateAdd", int32Args(args)...)
 	return g
 }
 
 // DateDiff adds the dateDiff step to the GraphTraversal.
 func (g *GraphTraversal) DateDiff(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("dateDiff", args...)
+	g.GremlinLang.AddStep("dateDiff", args...)
 	return g
 }
 
 // Dedup adds the dedup step to the GraphTraversal.
 func (g *GraphTraversal) Dedup(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("dedup", args...)
+	g.GremlinLang.AddStep("dedup", args...)
 	return g
 }
 
 // Difference adds the difference step to the GraphTraversal.
 func (g *GraphTraversal) Difference(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("difference", args...)
+	g.GremlinLang.AddStep("difference", args...)
 	return g
 }
 
 // Discard adds the discard step to the GraphTraversal.
 func (g *GraphTraversal) Discard(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("discard", args...)
+	g.GremlinLang.AddStep("discard", args...)
 	return g
 }
 
 // Disjunct adds the disjunct step to the GraphTraversal.
 func (g *GraphTraversal) Disjunct(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("disjunct", args...)
+	g.GremlinLang.AddStep("disjunct", args...)
 	return g
 }
 
 // Drop adds the drop step to the GraphTraversal.
 func (g *GraphTraversal) Drop(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("drop", args...)
+	g.GremlinLang.AddStep("drop", args...)
 	return g
 }
 
 // Element adds the element step to the GraphTraversal.
 func (g *GraphTraversal) Element(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("element", args...)
+	g.GremlinLang.AddStep("element", args...)
 	return g
 }
 
 // ElementMap adds the elementMap step to the GraphTraversal.
 func (g *GraphTraversal) ElementMap(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("elementMap", args...)
+	g.GremlinLang.AddStep("elementMap", args...)
 	return g
 }
 
 // Emit adds the emit step to the GraphTraversal.
 func (g *GraphTraversal) Emit(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("emit", args...)
+	g.GremlinLang.AddStep("emit", args...)
 	return g
 }
 
 // Fail adds the fail step to the GraphTraversal.
 func (g *GraphTraversal) Fail(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("fail", args...)
+	g.GremlinLang.AddStep("fail", args...)
 	return g
 }
 
 // Filter adds the filter step to the GraphTraversal.
 func (g *GraphTraversal) Filter(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("filter", args...)
+	g.GremlinLang.AddStep("filter", args...)
 	return g
 }
 
 // FlatMap adds the flatMap step to the GraphTraversal.
 func (g *GraphTraversal) FlatMap(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("flatMap", args...)
+	g.GremlinLang.AddStep("flatMap", args...)
 	return g
 }
 
 // Fold adds the fold step to the GraphTraversal.
 func (g *GraphTraversal) Fold(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("fold", args...)
+	g.GremlinLang.AddStep("fold", args...)
 	return g
 }
 
 // Format adds the format step to the GraphTraversal.
 func (g *GraphTraversal) Format(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("format", args...)
+	g.GremlinLang.AddStep("format", args...)
 	return g
 }
 
@@ -342,189 +345,189 @@ func (g *GraphTraversal) From(args ...interface{}) *GraphTraversal {
 			args[i] = v.Id
 		}
 	}
-	g.Bytecode.AddStep("from", args...)
+	g.GremlinLang.AddStep("from", args...)
 	return g
 }
 
 // Group adds the group step to the GraphTraversal.
 func (g *GraphTraversal) Group(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("group", args...)
+	g.GremlinLang.AddStep("group", args...)
 	return g
 }
 
 // GroupCount adds the groupCount step to the GraphTraversal.
 func (g *GraphTraversal) GroupCount(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("groupCount", args...)
+	g.GremlinLang.AddStep("groupCount", args...)
 	return g
 }
 
 // Has adds the has step to the GraphTraversal.
 func (g *GraphTraversal) Has(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("has", args...)
+	g.GremlinLang.AddStep("has", args...)
 	return g
 }
 
 // HasId adds the hasId step to the GraphTraversal.
 func (g *GraphTraversal) HasId(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("hasId", args...)
+	g.GremlinLang.AddStep("hasId", args...)
 	return g
 }
 
 // HasKey adds the hasKey step to the GraphTraversal.
 func (g *GraphTraversal) HasKey(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("hasKey", args...)
+	g.GremlinLang.AddStep("hasKey", args...)
 	return g
 }
 
 // HasLabel adds the hasLabel step to the GraphTraversal.
 func (g *GraphTraversal) HasLabel(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("hasLabel", args...)
+	g.GremlinLang.AddStep("hasLabel", args...)
 	return g
 }
 
 // HasNot adds the hasNot step to the GraphTraversal.
 func (g *GraphTraversal) HasNot(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("hasNot", args...)
+	g.GremlinLang.AddStep("hasNot", args...)
 	return g
 }
 
 // HasValue adds the hasValue step to the GraphTraversal.
 func (g *GraphTraversal) HasValue(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("hasValue", args...)
+	g.GremlinLang.AddStep("hasValue", args...)
 	return g
 }
 
 // Id adds the id step to the GraphTraversal.
 func (g *GraphTraversal) Id(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("id", args...)
+	g.GremlinLang.AddStep("id", args...)
 	return g
 }
 
 // Identity adds the identity step to the GraphTraversal.
 func (g *GraphTraversal) Identity(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("identity", args...)
+	g.GremlinLang.AddStep("identity", args...)
 	return g
 }
 
 // InE adds the inE step to the GraphTraversal.
 func (g *GraphTraversal) InE(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("inE", args...)
+	g.GremlinLang.AddStep("inE", args...)
 	return g
 }
 
 // InV adds the inV step to the GraphTraversal.
 func (g *GraphTraversal) InV(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("inV", args...)
+	g.GremlinLang.AddStep("inV", args...)
 	return g
 }
 
 // In adds the in step to the GraphTraversal.
 func (g *GraphTraversal) In(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("in", args...)
+	g.GremlinLang.AddStep("in", args...)
 	return g
 }
 
 // Index adds the index step to the GraphTraversal.
 func (g *GraphTraversal) Index(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("index", args...)
+	g.GremlinLang.AddStep("index", args...)
 	return g
 }
 
 // Inject adds the inject step to the GraphTraversal.
 func (g *GraphTraversal) Inject(args ...interface{}) *GraphTraversal {
 	// Force int32 serialization for valid number values for server compatibility
-	g.Bytecode.AddStep("inject", int32Args(args)...)
+	g.GremlinLang.AddStep("inject", int32Args(args)...)
 	return g
 }
 
 // Intersect adds the intersect step to the GraphTraversal.
 func (g *GraphTraversal) Intersect(args ...interface{}) *GraphTraversal {
 	// Force int32 serialization for valid number values for server compatibility
-	g.Bytecode.AddStep("intersect", args...)
+	g.GremlinLang.AddStep("intersect", args...)
 	return g
 }
 
 // Is adds the is step to the GraphTraversal.
 func (g *GraphTraversal) Is(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("is", args...)
+	g.GremlinLang.AddStep("is", args...)
 	return g
 }
 
 // Key adds the key step to the GraphTraversal.
 func (g *GraphTraversal) Key(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("key", args...)
+	g.GremlinLang.AddStep("key", args...)
 	return g
 }
 
 // Label adds the label step to the GraphTraversal.
 func (g *GraphTraversal) Label(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("label", args...)
+	g.GremlinLang.AddStep("label", args...)
 	return g
 }
 
 // Length adds the length step to the GraphTraversal.
 func (g *GraphTraversal) Length(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("length", args...)
+	g.GremlinLang.AddStep("length", args...)
 	return g
 }
 
 // Limit adds the limit step to the GraphTraversal.
 func (g *GraphTraversal) Limit(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("limit", args...)
+	g.GremlinLang.AddStep("limit", args...)
 	return g
 }
 
 // Local adds the local step to the GraphTraversal.
 func (g *GraphTraversal) Local(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("local", args...)
+	g.GremlinLang.AddStep("local", args...)
 	return g
 }
 
 // Loops adds the loops step to the GraphTraversal.
 func (g *GraphTraversal) Loops(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("loops", args...)
+	g.GremlinLang.AddStep("loops", args...)
 	return g
 }
 
 // LTrim adds the lTrim step to the GraphTraversal.
 func (g *GraphTraversal) LTrim(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("lTrim", args...)
+	g.GremlinLang.AddStep("lTrim", args...)
 	return g
 }
 
 // Map adds the map step to the GraphTraversal.
 func (g *GraphTraversal) Map(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("map", args...)
+	g.GremlinLang.AddStep("map", args...)
 	return g
 }
 
 // Match adds the match step to the GraphTraversal.
 func (g *GraphTraversal) Match(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("match", args...)
+	g.GremlinLang.AddStep("match", args...)
 	return g
 }
 
 // Math adds the math step to the GraphTraversal.
 func (g *GraphTraversal) Math(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("math", args...)
+	g.GremlinLang.AddStep("math", args...)
 	return g
 }
 
 // Max adds the max step to the GraphTraversal.
 func (g *GraphTraversal) Max(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("max", args...)
+	g.GremlinLang.AddStep("max", args...)
 	return g
 }
 
 // Mean adds the mean step to the GraphTraversal.
 func (g *GraphTraversal) Mean(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("mean", args...)
+	g.GremlinLang.AddStep("mean", args...)
 	return g
 }
 
 // Merge adds the merge step to the GraphTraversal.
 func (g *GraphTraversal) Merge(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("merge", args...)
+	g.GremlinLang.AddStep("merge", args...)
 	return g
 }
 
@@ -540,261 +543,261 @@ func (g *GraphTraversal) MergeE(args ...interface{}) *GraphTraversal {
 			}
 		}
 	}
-	g.Bytecode.AddStep("mergeE", args...)
+	g.GremlinLang.AddStep("mergeE", args...)
 	return g
 }
 
 // MergeV adds the mergeE step to the GraphTraversal.
 func (g *GraphTraversal) MergeV(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("mergeV", args...)
+	g.GremlinLang.AddStep("mergeV", args...)
 	return g
 }
 
 // Min adds the min step to the GraphTraversal.
 func (g *GraphTraversal) Min(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("min", args...)
+	g.GremlinLang.AddStep("min", args...)
 	return g
 }
 
 // None adds the none step to the GraphTraversal.
 func (g *GraphTraversal) None(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("none", args...)
+	g.GremlinLang.AddStep("none", args...)
 	return g
 }
 
 // Not adds the not step to the GraphTraversal.
 func (g *GraphTraversal) Not(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("not", args...)
+	g.GremlinLang.AddStep("not", args...)
 	return g
 }
 
 // Option adds the option step to the GraphTraversal.
 func (g *GraphTraversal) Option(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("option", args...)
+	g.GremlinLang.AddStep("option", args...)
 	return g
 }
 
 // Optional adds the optional step to the GraphTraversal.
 func (g *GraphTraversal) Optional(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("optional", args...)
+	g.GremlinLang.AddStep("optional", args...)
 	return g
 }
 
 // Or adds the or step to the GraphTraversal.
 func (g *GraphTraversal) Or(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("or", args...)
+	g.GremlinLang.AddStep("or", args...)
 	return g
 }
 
 // Order adds the order step to the GraphTraversal.
 func (g *GraphTraversal) Order(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("order", args...)
+	g.GremlinLang.AddStep("order", args...)
 	return g
 }
 
 // OtherV adds the otherV step to the GraphTraversal.
 func (g *GraphTraversal) OtherV(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("otherV", args...)
+	g.GremlinLang.AddStep("otherV", args...)
 	return g
 }
 
 // Out adds the out step to the GraphTraversal.
 func (g *GraphTraversal) Out(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("out", args...)
+	g.GremlinLang.AddStep("out", args...)
 	return g
 }
 
 // OutE adds the outE step to the GraphTraversal.
 func (g *GraphTraversal) OutE(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("outE", args...)
+	g.GremlinLang.AddStep("outE", args...)
 	return g
 }
 
 // OutV adds the outV step to the GraphTraversal.
 func (g *GraphTraversal) OutV(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("outV", args...)
+	g.GremlinLang.AddStep("outV", args...)
 	return g
 }
 
 // PageRank adds the pageRank step to the GraphTraversal.
 func (g *GraphTraversal) PageRank(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("pageRank", args...)
+	g.GremlinLang.AddStep("pageRank", args...)
 	return g
 }
 
 // Path adds the path step to the GraphTraversal.
 func (g *GraphTraversal) Path(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("path", args...)
+	g.GremlinLang.AddStep("path", args...)
 	return g
 }
 
 // PeerPressure adds the peerPressure step to the GraphTraversal.
 func (g *GraphTraversal) PeerPressure(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("peerPressure", args...)
+	g.GremlinLang.AddStep("peerPressure", args...)
 	return g
 }
 
 // Product adds the product step to the GraphTraversal.
 func (g *GraphTraversal) Product(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("product", args...)
+	g.GremlinLang.AddStep("product", args...)
 	return g
 }
 
 // Profile adds the profile step to the GraphTraversal.
 func (g *GraphTraversal) Profile(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("profile", args...)
+	g.GremlinLang.AddStep("profile", args...)
 	return g
 }
 
 // Program adds the program step to the GraphTraversal.
 func (g *GraphTraversal) Program(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("program", args...)
+	g.GremlinLang.AddStep("program", args...)
 	return g
 }
 
 // Project adds the project step to the GraphTraversal.
 func (g *GraphTraversal) Project(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("project", args...)
+	g.GremlinLang.AddStep("project", args...)
 	return g
 }
 
 // Properties adds the properties step to the GraphTraversal.
 func (g *GraphTraversal) Properties(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("properties", args...)
+	g.GremlinLang.AddStep("properties", args...)
 	return g
 }
 
 // Property adds the property step to the GraphTraversal.
 func (g *GraphTraversal) Property(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("property", args...)
+	g.GremlinLang.AddStep("property", args...)
 	return g
 }
 
 // PropertyMap adds the propertyMap step to the GraphTraversal.
 func (g *GraphTraversal) PropertyMap(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("propertyMap", args...)
+	g.GremlinLang.AddStep("propertyMap", args...)
 	return g
 }
 
 // Range adds the range step to the GraphTraversal.
 func (g *GraphTraversal) Range(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("range", args...)
+	g.GremlinLang.AddStep("range", args...)
 	return g
 }
 
 // Read adds the read step to the GraphTraversal.
 func (g *GraphTraversal) Read(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("read", args...)
+	g.GremlinLang.AddStep("read", args...)
 	return g
 }
 
 // Repeat adds the repeat step to the GraphTraversal.
 func (g *GraphTraversal) Repeat(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("repeat", args...)
+	g.GremlinLang.AddStep("repeat", args...)
 	return g
 }
 
 // Replace adds the replace step to the GraphTraversal.
 func (g *GraphTraversal) Replace(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("replace", args...)
+	g.GremlinLang.AddStep("replace", args...)
 	return g
 }
 
 // Reverse adds the reverse step to the GraphTraversal.
 func (g *GraphTraversal) Reverse(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("reverse", args...)
+	g.GremlinLang.AddStep("reverse", args...)
 	return g
 }
 
 // RTrim adds the repeat step to the GraphTraversal.
 func (g *GraphTraversal) RTrim(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("rTrim", args...)
+	g.GremlinLang.AddStep("rTrim", args...)
 	return g
 }
 
 // Sack adds the sack step to the GraphTraversal.
 func (g *GraphTraversal) Sack(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("sack", args...)
+	g.GremlinLang.AddStep("sack", args...)
 	return g
 }
 
 // Sample adds the sample step to the GraphTraversal.
 func (g *GraphTraversal) Sample(args ...interface{}) *GraphTraversal {
 	// Force int32 serialization for valid number values for server compatibility
-	g.Bytecode.AddStep("sample", int32Args(args)...)
+	g.GremlinLang.AddStep("sample", int32Args(args)...)
 	return g
 }
 
 // Select adds the select step to the GraphTraversal.
 func (g *GraphTraversal) Select(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("select", args...)
+	g.GremlinLang.AddStep("select", args...)
 	return g
 }
 
 // ShortestPath adds the shortestPath step to the GraphTraversal.
 func (g *GraphTraversal) ShortestPath(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("shortestPath", args...)
+	g.GremlinLang.AddStep("shortestPath", args...)
 	return g
 }
 
 // SideEffect adds the sideEffect step to the GraphTraversal.
 func (g *GraphTraversal) SideEffect(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("sideEffect", args...)
+	g.GremlinLang.AddStep("sideEffect", args...)
 	return g
 }
 
 // SimplePath adds the simplePath step to the GraphTraversal.
 func (g *GraphTraversal) SimplePath(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("simplePath", args...)
+	g.GremlinLang.AddStep("simplePath", args...)
 	return g
 }
 
 // Skip adds the skip step to the GraphTraversal.
 func (g *GraphTraversal) Skip(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("skip", args...)
+	g.GremlinLang.AddStep("skip", args...)
 	return g
 }
 
 // Split adds the split step to the GraphTraversal.
 func (g *GraphTraversal) Split(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("split", args...)
+	g.GremlinLang.AddStep("split", args...)
 	return g
 }
 
 // Subgraph adds the subgraph step to the GraphTraversal.
 func (g *GraphTraversal) Subgraph(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("subgraph", args...)
+	g.GremlinLang.AddStep("subgraph", args...)
 	return g
 }
 
 // Substring adds the substring step to the GraphTraversal.
 func (g *GraphTraversal) Substring(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("substring", int32Args(args)...)
+	g.GremlinLang.AddStep("substring", int32Args(args)...)
 	return g
 }
 
 // Sum adds the sum step to the GraphTraversal.
 func (g *GraphTraversal) Sum(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("sum", args...)
+	g.GremlinLang.AddStep("sum", args...)
 	return g
 }
 
 // Tail adds the tail step to the GraphTraversal.
 func (g *GraphTraversal) Tail(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("tail", args...)
+	g.GremlinLang.AddStep("tail", args...)
 	return g
 }
 
 // TimeLimit adds the timeLimit step to the GraphTraversal.
 func (g *GraphTraversal) TimeLimit(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("timeLimit", args...)
+	g.GremlinLang.AddStep("timeLimit", args...)
 	return g
 }
 
 // Times adds the times step to the GraphTraversal.
 func (g *GraphTraversal) Times(args ...interface{}) *GraphTraversal {
 	// Force int32 serialization for valid number values for server compatibility
-	g.Bytecode.AddStep("times", int32Args(args)...)
+	g.GremlinLang.AddStep("times", int32Args(args)...)
 	return g
 }
 
@@ -805,98 +808,98 @@ func (g *GraphTraversal) To(args ...interface{}) *GraphTraversal {
 			args[i] = v.Id
 		}
 	}
-	g.Bytecode.AddStep("to", args...)
+	g.GremlinLang.AddStep("to", args...)
 	return g
 }
 
 // ToE adds the toE step to the GraphTraversal.
 func (g *GraphTraversal) ToE(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("toE", args...)
+	g.GremlinLang.AddStep("toE", args...)
 	return g
 }
 
 // ToLower adds the toLower step to the GraphTraversal.
 func (g *GraphTraversal) ToLower(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("toLower", args...)
+	g.GremlinLang.AddStep("toLower", args...)
 	return g
 }
 
 // ToUpper adds the toUpper step to the GraphTraversal.
 func (g *GraphTraversal) ToUpper(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("toUpper", args...)
+	g.GremlinLang.AddStep("toUpper", args...)
 	return g
 }
 
 // ToV adds the toV step to the GraphTraversal.
 func (g *GraphTraversal) ToV(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("toV", args...)
+	g.GremlinLang.AddStep("toV", args...)
 	return g
 }
 
 // Tree adds the tree step to the GraphTraversal.
 func (g *GraphTraversal) Tree(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("tree", args...)
+	g.GremlinLang.AddStep("tree", args...)
 	return g
 }
 
 // Trim adds the tree step to the GraphTraversal.
 func (g *GraphTraversal) Trim(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("trim", args...)
+	g.GremlinLang.AddStep("trim", args...)
 	return g
 }
 
 // Unfold adds the unfold step to the GraphTraversal.
 func (g *GraphTraversal) Unfold(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("unfold", args...)
+	g.GremlinLang.AddStep("unfold", args...)
 	return g
 }
 
 // Union adds the union step to the GraphTraversal.
 func (g *GraphTraversal) Union(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("union", args...)
+	g.GremlinLang.AddStep("union", args...)
 	return g
 }
 
 // Until adds the until step to the GraphTraversal.
 func (g *GraphTraversal) Until(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("until", args...)
+	g.GremlinLang.AddStep("until", args...)
 	return g
 }
 
 // Value adds the value step to the GraphTraversal.
 func (g *GraphTraversal) Value(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("value", args...)
+	g.GremlinLang.AddStep("value", args...)
 	return g
 }
 
 // ValueMap adds the valueMap step to the GraphTraversal.
 func (g *GraphTraversal) ValueMap(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("valueMap", args...)
+	g.GremlinLang.AddStep("valueMap", args...)
 	return g
 }
 
 // Values adds the values step to the GraphTraversal.
 func (g *GraphTraversal) Values(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("values", args...)
+	g.GremlinLang.AddStep("values", args...)
 	return g
 }
 
 // Where adds the where step to the GraphTraversal.
 func (g *GraphTraversal) Where(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("where", args...)
+	g.GremlinLang.AddStep("where", args...)
 	return g
 }
 
 // With adds the with step to the GraphTraversal.
 func (g *GraphTraversal) With(args ...interface{}) *GraphTraversal {
 	// Force int32 serialization for valid number values for server compatibility
-	g.Bytecode.AddStep("with", int32Args(args)...)
+	g.GremlinLang.AddStep("with", int32Args(args)...)
 	return g
 }
 
 // Write adds the write step to the GraphTraversal.
 func (g *GraphTraversal) Write(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("write", args...)
+	g.GremlinLang.AddStep("write", args...)
 	return g
 }
 
@@ -944,8 +947,8 @@ func (t *Transaction) Begin() (*GraphTraversalSource, error) {
 	}
 
 	gts := &GraphTraversalSource{
-		graph:    t.g.graph,
-		bytecode: t.g.bytecode}
+		graph:            t.g.graph,
+		gremlinLang:      t.g.gremlinLang}
 	return gts, nil
 }
 
diff --git a/gremlin-go/driver/graphTraversalSource.go b/gremlin-go/driver/graphTraversalSource.go
index d90825003a..12ae62b0f7 100644
--- a/gremlin-go/driver/graphTraversalSource.go
+++ b/gremlin-go/driver/graphTraversalSource.go
@@ -30,7 +30,7 @@ func convertStrategyVarargs(strategies []TraversalStrategy) []interface{} {
 // GraphTraversalSource can be used to start GraphTraversal.
 type GraphTraversalSource struct {
 	graph            *Graph
-	bytecode         *Bytecode
+	gremlinLang      *GremlinLang
 	remoteConnection *DriverRemoteConnection
 	graphTraversal   *GraphTraversal
 }
@@ -39,34 +39,34 @@ type GraphTraversalSource struct {
 // Graph and DriverRemoteConnection can be set to nil as valid default values.
 func NewGraphTraversalSource(graph *Graph, remoteConnection *DriverRemoteConnection,
 	traversalStrategies ...TraversalStrategy) *GraphTraversalSource {
-	convertedArgs := convertStrategyVarargs(traversalStrategies)
-	bc := NewBytecode(nil)
-	bc.AddSource("withStrategies", convertedArgs...)
-	return &GraphTraversalSource{graph: graph, bytecode: bc, remoteConnection: remoteConnection}
+	// TODO: revisit when updating strategies
+	gl := NewGremlinLang(nil)
+	return &GraphTraversalSource{graph: graph, gremlinLang: gl, remoteConnection: remoteConnection}
 }
 
 // NewDefaultGraphTraversalSource creates a new graph GraphTraversalSource without a graph, strategy, or existing traversal.
 func NewDefaultGraphTraversalSource() *GraphTraversalSource {
-	return &GraphTraversalSource{graph: nil, bytecode: NewBytecode(nil), remoteConnection: nil}
+	return &GraphTraversalSource{graph: nil, gremlinLang: NewGremlinLang(nil), remoteConnection: nil}
 }
 
 // GetBytecode gets the traversal Bytecode associated with this graph traversal source.
+// TODO remove
 func (gts *GraphTraversalSource) GetBytecode() *Bytecode {
-	return gts.bytecode
+	return nil
 }
 
 // GetGraphTraversal gets the graph traversal associated with this graph traversal source.
 func (gts *GraphTraversalSource) GetGraphTraversal() *GraphTraversal {
-	return NewGraphTraversal(gts.graph, NewBytecode(gts.bytecode), gts.remoteConnection)
+	return NewGraphTraversal(gts.graph, NewGremlinLang(gts.gremlinLang), gts.remoteConnection)
 }
 
 func (gts *GraphTraversalSource) clone() *GraphTraversalSource {
-	return cloneGraphTraversalSource(gts.graph, NewBytecode(gts.bytecode), gts.remoteConnection)
+	return cloneGraphTraversalSource(gts.graph, NewGremlinLang(gts.gremlinLang), gts.remoteConnection)
 }
 
-func cloneGraphTraversalSource(graph *Graph, bc *Bytecode, remoteConnection *DriverRemoteConnection) *GraphTraversalSource {
+func cloneGraphTraversalSource(graph *Graph, gl *GremlinLang, remoteConnection *DriverRemoteConnection) *GraphTraversalSource {
 	return &GraphTraversalSource{graph: graph,
-		bytecode:         bc,
+		gremlinLang:      gl,
 		remoteConnection: remoteConnection,
 	}
 }
@@ -74,17 +74,14 @@ func cloneGraphTraversalSource(graph *Graph, bc *Bytecode, remoteConnection *Dri
 // WithBulk allows for control of bulking operations.
 func (gts *GraphTraversalSource) WithBulk(args ...interface{}) *GraphTraversalSource {
 	source := gts.clone()
-	err := source.bytecode.AddSource("withBulk", args...)
-	if err != nil {
-		return nil
-	}
+	source.gremlinLang.AddSource("withBulk", args...)
 	return source
 }
 
 // WithPath adds a path to be used throughout the life of a spawned Traversal.
 func (gts *GraphTraversalSource) WithPath(args ...interface{}) *GraphTraversalSource {
 	source := gts.clone()
-	source.bytecode.AddSource("withPath", args...)
+	source.gremlinLang.AddSource("withPath", args...)
 	return source
 }
 
@@ -92,14 +89,14 @@ func (gts *GraphTraversalSource) WithPath(args ...interface{}) *GraphTraversalSo
 func (gts *GraphTraversalSource) WithSack(args ...interface{}) *GraphTraversalSource {
 	source := gts.clone()
 	// Force int32 serialization for valid number values for server compatibility
-	source.bytecode.AddSource("withSack", int32Args(args)...)
+	source.gremlinLang.AddSource("withSack", int32Args(args)...)
 	return source
 }
 
 // WithSideEffect adds a side effect to be used throughout the life of a spawned Traversal.
 func (gts *GraphTraversalSource) WithSideEffect(args ...interface{}) *GraphTraversalSource {
 	source := gts.clone()
-	source.bytecode.AddSource("withSideEffect", args...)
+	source.gremlinLang.AddSource("withSideEffect", args...)
 	return source
 }
 
@@ -107,7 +104,7 @@ func (gts *GraphTraversalSource) WithSideEffect(args ...interface{}) *GraphTrave
 func (gts *GraphTraversalSource) WithStrategies(args ...TraversalStrategy) *GraphTraversalSource {
 	convertedArgs := convertStrategyVarargs(args)
 	source := gts.clone()
-	source.bytecode.AddSource("withStrategies", convertedArgs...)
+	source.gremlinLang.AddSource("withStrategies", convertedArgs...)
 	return source
 }
 
@@ -115,7 +112,7 @@ func (gts *GraphTraversalSource) WithStrategies(args ...TraversalStrategy) *Grap
 func (gts *GraphTraversalSource) WithoutStrategies(args ...TraversalStrategy) *GraphTraversalSource {
 	convertedArgs := convertStrategyVarargs(args)
 	source := gts.clone()
-	source.bytecode.AddSource("withoutStrategies", convertedArgs...)
+	source.gremlinLang.AddSource("withoutStrategies", convertedArgs...)
 	return source
 }
 
@@ -123,13 +120,10 @@ func (gts *GraphTraversalSource) WithoutStrategies(args ...TraversalStrategy) *G
 func (gts *GraphTraversalSource) With(key interface{}, value interface{}) *GraphTraversalSource {
 	source := gts.clone()
 
+	//TODO verify remote when connection is set-up
 	var optionsStrategy TraversalStrategy = nil
-	for _, v := range gts.bytecode.sourceInstructions {
-		if v.operator == "withStrategies" &&
-			v.arguments[0].(*traversalStrategy).name == decorationNamespace+"OptionsStrategy" {
-			optionsStrategy = v.arguments[0]
-			break
-		}
+	if len(gts.gremlinLang.optionsStrategies) != 0 {
+		optionsStrategy = gts.gremlinLang.optionsStrategies[0]
 	}
 
 	if optionsStrategy == nil {
@@ -154,7 +148,7 @@ func (gts *GraphTraversalSource) WithRemote(remoteConnection *DriverRemoteConnec
 // E reads edges from the graph to start the traversal.
 func (gts *GraphTraversalSource) E(args ...interface{}) *GraphTraversal {
 	traversal := gts.GetGraphTraversal()
-	traversal.Bytecode.AddStep("E", args...)
+	traversal.GremlinLang.AddStep("E", args...)
 	return traversal
 }
 
@@ -166,28 +160,28 @@ func (gts *GraphTraversalSource) V(args ...interface{}) *GraphTraversal {
 		}
 	}
 	traversal := gts.GetGraphTraversal()
-	traversal.Bytecode.AddStep("V", args...)
+	traversal.GremlinLang.AddStep("V", args...)
 	return traversal
 }
 
 // AddE adds an Edge to start the traversal.
 func (gts *GraphTraversalSource) AddE(args ...interface{}) *GraphTraversal {
 	traversal := gts.GetGraphTraversal()
-	traversal.Bytecode.AddStep("addE", args...)
+	traversal.GremlinLang.AddStep("addE", args...)
 	return traversal
 }
 
 // AddV adds a Vertex to start the traversal.
 func (gts *GraphTraversalSource) AddV(args ...interface{}) *GraphTraversal {
 	traversal := gts.GetGraphTraversal()
-	traversal.Bytecode.AddStep("addV", args...)
+	traversal.GremlinLang.AddStep("addV", args...)
 	return traversal
 }
 
 // Call starts the traversal by executing a procedure
 func (gts *GraphTraversalSource) Call(args ...interface{}) *GraphTraversal {
 	traversal := gts.GetGraphTraversal()
-	traversal.Bytecode.AddStep("call", args...)
+	traversal.GremlinLang.AddStep("call", args...)
 	return traversal
 }
 
@@ -195,14 +189,14 @@ func (gts *GraphTraversalSource) Call(args ...interface{}) *GraphTraversal {
 func (gts *GraphTraversalSource) Inject(args ...interface{}) *GraphTraversal {
 	traversal := gts.GetGraphTraversal()
 	// Force int32 serialization for valid number values for server compatibility
-	traversal.Bytecode.AddStep("inject", int32Args(args)...)
+	traversal.GremlinLang.AddStep("inject", int32Args(args)...)
 	return traversal
 }
 
 // Io adds the io steps to start the traversal.
 func (gts *GraphTraversalSource) Io(args ...interface{}) *GraphTraversal {
 	traversal := gts.GetGraphTraversal()
-	traversal.Bytecode.AddStep("io", args...)
+	traversal.GremlinLang.AddStep("io", args...)
 	return traversal
 }
 
@@ -219,21 +213,21 @@ func (gts *GraphTraversalSource) MergeE(args ...interface{}) *GraphTraversal {
 		}
 	}
 	traversal := gts.GetGraphTraversal()
-	traversal.Bytecode.AddStep("mergeE", args...)
+	traversal.GremlinLang.AddStep("mergeE", args...)
 	return traversal
 }
 
 // MergeV uses an upsert-like operation to add a Vertex to start the traversal.
 func (gts *GraphTraversalSource) MergeV(args ...interface{}) *GraphTraversal {
 	traversal := gts.GetGraphTraversal()
-	traversal.Bytecode.AddStep("mergeV", args...)
+	traversal.GremlinLang.AddStep("mergeV", args...)
 	return traversal
 }
 
 // Union allows for a multi-branched start to a traversal.
 func (gts *GraphTraversalSource) Union(args ...interface{}) *GraphTraversal {
 	traversal := gts.GetGraphTraversal()
-	traversal.Bytecode.AddStep("union", args...)
+	traversal.GremlinLang.AddStep("union", args...)
 	return traversal
 }
 
diff --git a/gremlin-go/driver/graphTraversalSource_test.go b/gremlin-go/driver/graphTraversalSource_test.go
index f33c432d33..7a842e5e4b 100644
--- a/gremlin-go/driver/graphTraversalSource_test.go
+++ b/gremlin-go/driver/graphTraversalSource_test.go
@@ -28,41 +28,29 @@ func TestGraphTraversalSource(t *testing.T) {
 
 	t.Run("GraphTraversalSource.With tests", func(t *testing.T) {
 		t.Run("Test for single property", func(t *testing.T) {
-			g := &GraphTraversalSource{graph: &Graph{}, bytecode: NewBytecode(nil), remoteConnection: nil}
+			g := &GraphTraversalSource{graph: &Graph{}, gremlinLang: NewGremlinLang(nil), remoteConnection: nil}
 			traversal := g.With("foo", "bar")
 			assert.NotNil(t, traversal)
-			assert.Equal(t, 1, len(traversal.bytecode.sourceInstructions))
-			instruction := traversal.bytecode.sourceInstructions[0]
-			assert.Equal(t, "withStrategies", instruction.operator)
-			assert.Equal(t, "org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.OptionsStrategy",
-				instruction.arguments[0].(*traversalStrategy).name)
-			config := instruction.arguments[0].(*traversalStrategy).configuration
+			assert.Equal(t, 1, len(traversal.gremlinLang.optionsStrategies))
+			config := traversal.gremlinLang.optionsStrategies[0].configuration
 			assert.Equal(t, map[string]interface{}{"foo": "bar"}, config)
 		})
 
 		t.Run("Test for multiple property", func(t *testing.T) {
-			g := &GraphTraversalSource{graph: &Graph{}, bytecode: NewBytecode(nil), remoteConnection: nil}
+			g := &GraphTraversalSource{graph: &Graph{}, gremlinLang: NewGremlinLang(nil), remoteConnection: nil}
 			traversal := g.With("foo", "bar").With("foo2", "bar2")
 			assert.NotNil(t, traversal)
-			assert.Equal(t, 1, len(traversal.bytecode.sourceInstructions))
-			instruction := traversal.bytecode.sourceInstructions[0]
-			assert.Equal(t, "withStrategies", instruction.operator)
-			assert.Equal(t, "org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.OptionsStrategy",
-				instruction.arguments[0].(*traversalStrategy).name)
-			config := instruction.arguments[0].(*traversalStrategy).configuration
+			assert.Equal(t, 1, len(traversal.gremlinLang.optionsStrategies))
+			config := traversal.gremlinLang.optionsStrategies[0].configuration
 			assert.Equal(t, map[string]interface{}{"foo": "bar", "foo2": "bar2"}, config)
 		})
 
 		t.Run("Test for property replacement", func(t *testing.T) {
-			g := &GraphTraversalSource{graph: &Graph{}, bytecode: NewBytecode(nil), remoteConnection: nil}
+			g := &GraphTraversalSource{graph: &Graph{}, gremlinLang: NewGremlinLang(nil), remoteConnection: nil}
 			traversal := g.With("foo", "bar").With("foo", "not bar")
 			assert.NotNil(t, traversal)
-			assert.Equal(t, 1, len(traversal.bytecode.sourceInstructions))
-			instruction := traversal.bytecode.sourceInstructions[0]
-			assert.Equal(t, "withStrategies", instruction.operator)
-			assert.Equal(t, "org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.OptionsStrategy",
-				instruction.arguments[0].(*traversalStrategy).name)
-			config := instruction.arguments[0].(*traversalStrategy).configuration
+			assert.Equal(t, 1, len(traversal.gremlinLang.optionsStrategies))
+			config := traversal.gremlinLang.optionsStrategies[0].configuration
 			assert.Equal(t, map[string]interface{}{"foo": "not bar"}, config)
 		})
 	})
diff --git a/gremlin-go/driver/gremlinlang.go b/gremlin-go/driver/gremlinlang.go
new file mode 100644
index 0000000000..3a67515030
--- /dev/null
+++ b/gremlin-go/driver/gremlinlang.go
@@ -0,0 +1,538 @@
+/*
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements.  See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership.  The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License.  You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+*/
+
+package gremlingo
+
+import (
+	"fmt"
+	"go/token"
+	"math"
+	"math/big"
+	"reflect"
+	"strconv"
+	"strings"
+	"sync/atomic"
+	"time"
+)
+
+type GremlinLang struct {
+	emptyArray        []interface{}
+	gremlin           []string
+	parameters        map[string]interface{}
+	optionsStrategies []*traversalStrategy
+	paramCount        *atomic.Uint64
+}
+
+// NewGremlinLang creates a new GremlinLang to be used in traversals.
+func NewGremlinLang(gl *GremlinLang) *GremlinLang {
+	gremlin := make([]string, 0)
+	parameters := make(map[string]interface{})
+	optionsStrategies := make([]*traversalStrategy, 0)
+	paramCount := atomic.Uint64{}
+	if gl != nil {
+		gremlin = gl.gremlin
+		parameters = gl.parameters
+		optionsStrategies = gl.optionsStrategies
+		paramCount.Store(gl.paramCount.Load())
+	}
+
+	return &GremlinLang{
+		gremlin:           gremlin,
+		parameters:        parameters,
+		optionsStrategies: optionsStrategies,
+		paramCount:        &paramCount,
+	}
+}
+
+func (gl *GremlinLang) addToGremlin(name string, args ...interface{}) error {
+	flattenedArgs := gl.flattenArguments(args...)
+	if name == "CardinalityValueTraversal" {
+		gl.gremlin = append(gl.gremlin, "Cardinality.")
+		str0, err := gl.argAsString(flattenedArgs[0])
+		if err != nil {
+			return err
+		}
+		str1, err := gl.argAsString(flattenedArgs[1])
+		if err != nil {
+			return err
+		}
+		gl.gremlin = append(gl.gremlin, str0)
+		gl.gremlin = append(gl.gremlin, "(")
+		gl.gremlin = append(gl.gremlin, str1)
+		gl.gremlin = append(gl.gremlin, ")")
+	}
+
+	gl.gremlin = append(gl.gremlin, ".")
+	gl.gremlin = append(gl.gremlin, name)
+	gl.gremlin = append(gl.gremlin, "(")
+
+	for i := 0; i < len(flattenedArgs); i++ {
+		if i > 0 {
+			gl.gremlin = append(gl.gremlin, ",")
+		}
+		convertArg, err := gl.convertArgument(flattenedArgs[i]) //.Index(i).Interface())
+		if err != nil {
+			return err
+		}
+		argStr, err := gl.argAsString(convertArg)
+		if err != nil {
+			return err
+		}
+		gl.gremlin = append(gl.gremlin, argStr)
+	}
+	gl.gremlin = append(gl.gremlin, ")")
+	return nil
+}
+
+func (gl *GremlinLang) argAsString(arg interface{}) (string, error) {
+	if arg == nil {
+		return "null", nil
+	}
+	// we are concerned with both single and double quotes and %q in fmt only escapes double quotes
+	escapeQuotes := strings.NewReplacer(`'`, `\'`, `"`, `\"`)
+
+	switch v := arg.(type) {
+	case string:
+		return fmt.Sprintf("\"%s\"", escapeQuotes.Replace(v)), nil
+	case bool:
+		return strconv.FormatBool(v), nil
+	case uint8:
+		return fmt.Sprintf("%dB", v), nil
+	case int8, int16:
+		return fmt.Sprintf("%dS", v), nil
+	case int32, uint16:
+		return fmt.Sprintf("%d", v), nil
+	case int:
+		if v <= math.MaxInt32 && v >= math.MinInt32 {
+			return fmt.Sprintf("%d", v), nil
+		} else {
+			return fmt.Sprintf("%dL", v), nil
+		}
+	case int64, uint32:
+		return fmt.Sprintf("%dL", v), nil
+	case uint, uint64, *big.Int:
+		return fmt.Sprintf("%dN", v), nil
+	case float32:
+		if math.IsNaN(float64(v)) {
+			return "Nan", nil
+		}
+		if math.IsInf(float64(v), 1) {
+			return "Infinity", nil
+		}
+		if math.IsInf(float64(v), -1) {
+			return "-Infinity", nil
+		}
+		return fmt.Sprintf("%vF", v), nil
+	case float64:
+		if math.IsNaN(v) {
+			return "Nan", nil
+		}
+		if math.IsInf(v, 1) {
+			return "Infinity", nil
+		}
+		if math.IsInf(v, -1) {
+			return "-Infinity", nil
+		}
+		return fmt.Sprintf("%vD", v), nil
+	case *SimpleSet:
+		return gl.translateSlice(v.ToSlice())
+	case *BigDecimal, BigDecimal:
+		return fmt.Sprintf("%vM", v), nil
+	case time.Time:
+		return fmt.Sprintf("datetime(\"%v\")", v.Format(time.RFC3339)), nil
+	case cardinality, column, direction, operator, order, pick, pop, barrier, scope, t, merge:
+		name := reflect.ValueOf(v).Type().Name()
+		return fmt.Sprintf("%s.%s", strings.ToUpper(name[:1])+name[1:], v), nil
+	case *Vertex:
+		id, _ := gl.argAsString(v.Id)
+		return fmt.Sprintf("new ReferenceVertex(%s,\"%s\")", escapeQuotes.Replace(id), escapeQuotes.Replace(v.Label)), nil
+	case textP:
+		return gl.translateTextPredicate(&v)
+	case *textP:
+		return gl.translateTextPredicate(v)
+	case p:
+		return gl.translatePredicate(&v)
+	case *p:
+		return gl.translatePredicate(v)
+	case Traversal:
+		gremlinLang := v.GremlinLang
+		for key, val := range gremlinLang.parameters {
+			gl.parameters[key] = val
+		}
+		return gremlinLang.GetGremlin("__"), nil
+	case *Traversal:
+		gremlinLang := v.GremlinLang
+		for key, val := range gremlinLang.parameters {
+			gl.parameters[key] = val
+		}
+		return gremlinLang.GetGremlin("__"), nil
+	case GraphTraversal:
+		gremlinLang := v.GremlinLang
+		for key, val := range gremlinLang.parameters {
+			gl.parameters[key] = val
+		}
+		return gremlinLang.GetGremlin("__"), nil
+	case *GraphTraversal:
+		gremlinLang := v.GremlinLang
+		for key, val := range gremlinLang.parameters {
+			gl.parameters[key] = val
+		}
+		return gremlinLang.GetGremlin("__"), nil
+	case GremlinLang:
+		for key, val := range v.parameters {
+			gl.parameters[key] = val
+		}
+		return v.GetGremlin("__"), nil
+	case *GremlinLang:
+		for key, val := range v.parameters {
+			gl.parameters[key] = val
+		}
+		return v.GetGremlin("__"), nil
+	case GValue:
+		key := v.Name()
+		if !token.IsIdentifier(key) {
+			panic(fmt.Sprintf("invalid parameter name '%v'.", key))
+		}
+		value := v.Value()
+		if val, ok := gl.parameters[key]; ok {
+			if reflect.TypeOf(val).Kind() == reflect.Slice || reflect.TypeOf(value).Kind() == reflect.Slice ||
+				reflect.TypeOf(val).Kind() == reflect.Map || reflect.TypeOf(value).Kind() == reflect.Map {
+				if !reflect.DeepEqual(val, value) {
+					panic(fmt.Sprintf("parameter with name '%v' already exists.", key))
+				}
+			} else if val != value {
+				panic(fmt.Sprintf("parameter with name '%v' already exists.", key))
+			}
+		} else {
+			gl.parameters[key] = v.Value()
+		}
+		return key, nil
+	default:
+		switch reflect.TypeOf(arg).Kind() {
+		case reflect.Map:
+			return gl.translateMap(arg)
+		case reflect.Slice:
+			return gl.translateSlice(arg)
+		default:
+			return gl.asParameter(arg), nil
+		}
+	}
+}
+
+func (gl *GremlinLang) translateMap(arg interface{}) (string, error) {
+	sb := strings.Builder{}
+	sb.WriteString("[")
+	size := reflect.ValueOf(arg).Len()
+	if size == 0 {
+		sb.WriteString(":")
+	} else {
+		iter := reflect.ValueOf(arg).MapRange()
+		for iter.Next() {
+			k := iter.Key().Interface()
+			kString, err := gl.argAsString(k)
+			if err != nil {
+				return "", err
+			}
+			v := iter.Value().Interface()
+			vString, err := gl.argAsString(v)
+			if err != nil {
+				return "", err
+			}
+			sb.WriteString(kString)
+			sb.WriteByte(':')
+			sb.WriteString(vString)
+			size--
+			if size > 0 {
+				sb.WriteString(",")
+			}
+		}
+	}
+
+	sb.WriteString("]")
+	return sb.String(), nil
+}
+
+func (gl *GremlinLang) translateSlice(arg interface{}) (string, error) {
+	sb := strings.Builder{}
+	sb.WriteString("[")
+	list := reflect.ValueOf(arg)
+
+	for i := 0; i < list.Len(); i++ {
+		if i > 0 {
+			sb.WriteString(",")
+		}
+		vString, err := gl.argAsString(list.Index(i).Interface())
+		if err != nil {
+			return "", err
+		}
+		sb.WriteString(vString)
+	}
+	sb.WriteString("]")
+	return sb.String(), nil
+}
+
+func (gl *GremlinLang) translateTextPredicate(v *textP) (string, error) {
+	if v.operator == "" || len(v.values) == 0 {
+		return "", nil
+	}
+
+	instructionString := ""
+	instructionString += v.operator
+	instructionString += "("
+	if len(v.values) == 1 {
+		argString, err := gl.argAsString(v.values[0])
+		if err != nil {
+			return "", err
+		}
+		instructionString += argString
+	} else if len(v.values) > 1 {
+		for index, arg := range v.values {
+			argString, err := gl.argAsString(arg)
+			if err != nil {
+				return "", err
+			}
+
+			instructionString += argString
+			if index < len(v.values)-1 && argString != "" {
+				instructionString += ","
+			}
+		}
+	}
+
+	instructionString += ")"
+
+	return instructionString, nil
+}
+
+func (gl *GremlinLang) translatePredicate(v *p) (string, error) {
+
+	if v.operator == "" || len(v.values) == 0 {
+		return "", nil
+	}
+
+	instructionString := ""
+	instructionString += v.operator
+	instructionString += "("
+	if len(v.values) == 1 {
+		argString, err := gl.argAsString(v.values[0])
+		if err != nil {
+			return "", err
+		}
+		instructionString += argString
+	} else if len(v.values) > 1 {
+		if v.operator != "between" && v.operator != "inside" {
+			instructionString += "["
+		}
+		for index, arg := range v.values {
+			argString, err := gl.argAsString(arg)
+			if err != nil {
+				return "", err
+			}
+
+			instructionString += argString
+			if index < len(v.values)-1 && argString != "" {
+				instructionString += ","
+			}
+		}
+		if v.operator != "between" && v.operator != "inside" {
+			instructionString += "]"
+		}
+	}
+
+	instructionString += ")"
+
+	return instructionString, nil
+}
+func (gl *GremlinLang) asParameter(arg interface{}) string {
+	paramName := fmt.Sprintf("_%d", gl.paramCount.Load())
+	gl.paramCount.Add(1)
+	gl.parameters[paramName] = arg
+	return paramName
+}
+
+func (gl *GremlinLang) GetGremlin(arg ...string) string {
+	var g string
+	gremlin := strings.Join(gl.gremlin, "")
+	if len(arg) == 0 {
+		g = "g"
+	} else {
+		g = arg[0]
+	}
+	// special handling for CardinalityValueTraversal
+	if len(gl.gremlin) != 0 && string(gremlin[0]) != "." {
+		return gremlin
+	}
+	return g + gremlin
+}
+
+func (gl *GremlinLang) GetParameters() map[string]interface{} {
+	return gl.parameters
+}
+
+func (gl *GremlinLang) AddG(g string) {
+	gl.parameters["g"] = g
+}
+
+func (gl *GremlinLang) Reset() {
+	gl.paramCount.Store(0)
+}
+
+func (gl *GremlinLang) AddSource(name string, arguments ...interface{}) {
+	if name == "withStrategies" && len(arguments) != 0 {
+		args := gl.buildStrategyArgs(arguments...)
+		// possible to have empty strategies list to send
+		if len(args) != 0 {
+			gl.gremlin = append(gl.gremlin, ".withStrategies(")
+			gl.gremlin = append(gl.gremlin, args)
+			gl.gremlin = append(gl.gremlin, ")")
+		}
+		return
+	}
+	gl.addToGremlin(name, arguments)
+}
+
+func (gl *GremlinLang) buildStrategyArgs(args ...interface{}) string {
+	sb := strings.Builder{}
+	c := 0
+	for _, arg := range args {
+		if c > 0 {
+			sb.WriteString(",")
+		}
+		strategy, ok := arg.(*traversalStrategy)
+		if !ok {
+			// error?
+			continue
+		}
+		// special handling for OptionsStrategy
+		if strategy.name == "OptionsStrategy" {
+			gl.optionsStrategies = append(gl.optionsStrategies, strategy)
+			continue
+		}
+		if len(strategy.configuration) == 0 {
+			sb.WriteString(strategy.name)
+		} else {
+			sb.WriteString("new ")
+			sb.WriteString(strategy.name)
+			sb.WriteString("(")
+			ct := 0
+			for key, val := range strategy.configuration {
+				if ct > 0 {
+					sb.WriteString(",")
+				}
+				sb.WriteString(key)
+				sb.WriteString(":")
+				traversal, ok := val.(*Traversal)
+				if ok {
+					stringTraversal, _ := gl.argAsString(traversal.GremlinLang)
+					sb.WriteString(stringTraversal)
+				} else {
+					stringArg, _ := gl.argAsString(val)
+					sb.WriteString(stringArg)
+				}
+				ct++
+			}
+			sb.WriteString(")")
+		}
+		c++
+	}
+	return sb.String()
+}
+
+func (gl *GremlinLang) AddStep(stepName string, arguments ...interface{}) error {
+	err := gl.addToGremlin(stepName, arguments)
+	return err
+}
+
+func (gl *GremlinLang) GetOptionsStrategies() []*traversalStrategy {
+	return gl.optionsStrategies
+}
+
+func (gl *GremlinLang) IsEmpty() bool {
+	return len(gl.gremlin) == 0
+}
+
+func (gl *GremlinLang) flattenArguments(arguments ...interface{}) []interface{} {
+	if arguments == nil || len(arguments) == 0 {
+		return gl.emptyArray
+	}
+	flatArgs := make([]interface{}, 0)
+	for _, argument := range arguments {
+		arg, ok := argument.([]interface{})
+		if ok {
+			for _, nestedArg := range arg {
+				converted, _ := gl.convertArgument(nestedArg)
+				flatArgs = append(flatArgs, converted)
+			}
+		} else {
+			converted, _ := gl.convertArgument(argument)
+			flatArgs = append(flatArgs, converted)
+		}
+	}
+	return flatArgs
+}
+
+func (gl *GremlinLang) convertArgument(arg interface{}) (interface{}, error) {
+	if arg == nil {
+		return nil, nil
+	}
+	switch v := arg.(type) {
+	case *Traversal:
+		if v.graph != nil {
+			return nil, fmt.Errorf("the child traversal of %s was not spawned anonymously - "+
+				"use the __ class rather than a TraversalSource to construct the child traversal", arg)
+		}
+		return v.GremlinLang, nil
+	default:
+		switch reflect.TypeOf(arg).Kind() {
+		case reflect.Map:
+			argMap := reflect.ValueOf(arg)
+			newMap := make(map[interface{}]interface{}, argMap.Len())
+			for _, key := range argMap.MapKeys() {
+				convertKey, _ := gl.convertArgument(key.Interface())
+				convertValue, _ := gl.convertArgument(argMap.MapIndex(key).Interface())
+				newMap[convertKey] = convertValue
+			}
+			return newMap, nil
+		case reflect.Array, reflect.Slice:
+			argList := reflect.ValueOf(arg)
+			newList := make([]interface{}, argList.Len())
+			for i := 0; i < argList.Len(); i++ {
+				convertValue, _ := gl.convertArgument(argList.Index(i).Interface())
+				newList[i] = convertValue
+			}
+			return newList, nil
+		default:
+			return arg, nil
+		}
+	}
+}
+
+// TODO revisit and remove if necessary
+//var withOptionsMap map[any]string = map[any]string{
+//	WithOptions.Tokens:  "WithOptions.tokens",
+//	WithOptions.None:    "WithOptions.none",
+//	WithOptions.Ids:     "WithOptions.ids",
+//	WithOptions.Labels:  "WithOptions.labels",
+//	WithOptions.Keys:    "WithOptions.keys",
+//	WithOptions.Values:  "WithOptions.values",
+//	WithOptions.All:     "WithOptions.all",
+//	WithOptions.Indexer: "WithOptions.indexer",
+//	WithOptions.List:    "WithOptions.list",
+//	WithOptions.Map:     "WithOptions.map",
+//}
diff --git a/gremlin-go/driver/gremlinlang_test.go b/gremlin-go/driver/gremlinlang_test.go
new file mode 100644
index 0000000000..450bb729ff
--- /dev/null
+++ b/gremlin-go/driver/gremlinlang_test.go
@@ -0,0 +1,715 @@
+/*
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements.  See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership.  The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License.  You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+*/
+
+package gremlingo
+
+import (
+	"regexp"
+	"testing"
+	"time"
+)
+
+func Test_GremlinLang(t *testing.T) {
+	type test struct {
+		name                      string
+		assert                    func(g *GraphTraversalSource) *GraphTraversal
+		equals                    string
+		only                      bool
+		skip                      bool
+		wantErr                   bool
+		containsRandomClassParams bool
+	}
+	tests := []test{
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal { return g.V() },
+			equals: "g.V()",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal { return g.V("1", "2", "3", "4") },
+			equals: "g.V(\"1\",\"2\",\"3\",\"4\")",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal { return g.V("3").ValueMap(true) },
+			equals: "g.V(\"3\").valueMap(true)",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal { return g.V().Constant(5) },
+			equals: "g.V().constant(5)",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal { return g.V().Constant(1.5) },
+			equals: "g.V().constant(1.5D)",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal { return g.V().Constant("Hello") },
+			equals: "g.V().constant(\"Hello\")",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal { return g.V().HasLabel("airport").Limit(5) },
+			equals: "g.V().hasLabel(\"airport\").limit(5)",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal { return g.V().HasLabel(P.Within("a", "b", "c")) },
+			equals: "g.V().hasLabel(within([\"a\",\"b\",\"c\"]))",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().HasLabel("airport", "continent").Out().Limit(5)
+			},
+			equals: "g.V().hasLabel(\"airport\",\"continent\").out().limit(5)",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().HasLabel("airport").Out().Values("code").Limit(5)
+			},
+			equals: "g.V().hasLabel(\"airport\").out().values(\"code\").limit(5)",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V("3").As("a").Out("route").Limit(10).Where(P.Eq("a")).By("region")
+			},
+			equals: "g.V(\"3\").as(\"a\").out(\"route\").limit(10).where(eq(\"a\")).by(\"region\")",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V("3").Repeat(T__.Out("route").SimplePath()).Times(2).Path().By("code")
+			},
+			equals: "g.V(\"3\").repeat(__.out(\"route\").simplePath()).times(2).path().by(\"code\")",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().HasLabel("airport").Out().Has("region", "US-TX").Values("code").Limit(5)
+			},
+			equals: "g.V().hasLabel(\"airport\").out().has(\"region\",\"US-TX\").values(\"code\").limit(5)",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().HasLabel("airport").Union(T__.Values("city"), T__.Values("region")).Limit(5)
+			},
+			equals: "g.V().hasLabel(\"airport\").union(__.values(\"city\"),__.values(\"region\")).limit(5)",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal { return g.V("3").As("a").Out("route", "routes") },
+			equals: "g.V(\"3\").as(\"a\").out(\"route\",\"routes\")",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal { return g.V().Where(T__.Values("runways").Is(5)) },
+			equals: "g.V().where(__.values(\"runways\").is(5))",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V("3").Repeat(T__.Out().SimplePath()).Until(T__.Has("code", "AGR")).Path().By("code").Limit(5)
+			},
+			equals: "g.V(\"3\").repeat(__.out().simplePath()).until(__.has(\"code\",\"AGR\")).path().by(\"code\").limit(5)",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal { return g.V().HasLabel("airport").Order().By(T__.Id()) },
+			equals: "g.V().hasLabel(\"airport\").order().by(__.id())",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal { return g.V().HasLabel("airport").Order().By(T.Id) },
+			equals: "g.V().hasLabel(\"airport\").order().by(T.id)",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().HasLabel("airport").Order().By(T__.Id(), Order.Desc)
+			},
+			equals: "g.V().hasLabel(\"airport\").order().by(__.id(),Order.desc)",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().HasLabel("airport").Order().By("code", Order.Desc)
+			},
+			equals: "g.V().hasLabel(\"airport\").order().by(\"code\",Order.desc)",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V("1", "2", "3").Local(T__.Out().Out().Dedup().Fold())
+			},
+			equals: "g.V(\"1\",\"2\",\"3\").local(__.out().out().dedup().fold())",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V("3").Out().Path().Count(Scope.Local)
+			},
+			equals: "g.V(\"3\").out().path().count(Scope.local)",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.E().Count()
+			},
+			equals: "g.E().count()",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V("5").OutE("route").InV().Path().Limit(10)
+			},
+			equals: "g.V(\"5\").outE(\"route\").inV().path().limit(10)",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V("5").PropertyMap().Select(Column.Keys)
+			},
+			equals: "g.V(\"5\").propertyMap().select(Column.keys)",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V("5").PropertyMap().Select(Column.Values)
+			},
+			equals: "g.V(\"5\").propertyMap().select(Column.values)",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V("3").Values("runways").Math("_ + 1")
+			},
+			equals: "g.V(\"3\").values(\"runways\").math(\"_ + 1\")",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V("3").Emit().Repeat(T__.Out().SimplePath()).Times(3).Limit(5).Path()
+			},
+			equals: "g.V(\"3\").emit().repeat(__.out().simplePath()).times(3).limit(5).path()",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().Match(T__.As("a").Has("code", "LHR").As("b")).Select("b").By("code")
+			},
+			equals: "g.V().match(__.as(\"a\").has(\"code\",\"LHR\").as(\"b\")).select(\"b\").by(\"code\")",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().Has("test-using-keyword-as-property", "repeat")
+			},
+			equals: "g.V().has(\"test-using-keyword-as-property\",\"repeat\")",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V("1").AddE("test").To(T__.V("4"))
+			},
+			equals: "g.V(\"1\").addE(\"test\").to(__.V(\"4\"))",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().Values("runways").Max()
+			},
+			equals: "g.V().values(\"runways\").max()",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().Values("runways").Min()
+			},
+			equals: "g.V().values(\"runways\").min()",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().Values("runways").Sum()
+			},
+			equals: "g.V().values(\"runways\").sum()",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().Values("runways").Mean()
+			},
+			equals: "g.V().values(\"runways\").mean()",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.WithSack(0).V("3", "5").Sack(Operator.Sum).By("runways").Sack()
+			},
+			equals: "g.withSack(0).V(\"3\",\"5\").sack(Operator.sum).by(\"runways\").sack()",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V("3").Values("runways").Store("x").V("4").Values("runways").Store("x").By(T__.Constant(1)).V("6").Store("x").By(T__.Constant(1)).Select("x").Unfold().Sum()
+			},
+			equals: "g.V(\"3\").values(\"runways\").store(\"x\").V(\"4\").values(\"runways\").store(\"x\").by(__.constant(1)).V(\"6\").store(\"x\").by(__.constant(1)).select(\"x\").unfold().sum()",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.Inject(3, 4, 5)
+			},
+			equals: "g.inject(3,4,5)",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.Inject([]interface{}{3, 4, 5})
+			},
+			equals: "g.inject([3,4,5])",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.Inject(3, 4, 5).Count()
+			},
+			equals: "g.inject(3,4,5).count()",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().Has("runways", P.Gt(5)).Count()
+			},
+			equals: "g.V().has(\"runways\",gt(5)).count()",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().Has("runways", P.Lte(5.3)).Count()
+			},
+			equals: "g.V().has(\"runways\",lte(5.3D)).count()",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().Has("code", P.Within(123, 124))
+			},
+			equals: "g.V().has(\"code\",within([123,124]))",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().Has("code", P.Within(123, "abc"))
+			},
+			equals: "g.V().has(\"code\",within([123,\"abc\"]))",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().Has("code", P.Within("abc", 123))
+			},
+			equals: "g.V().has(\"code\",within([\"abc\",123]))",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().Has("code", P.Within("abc", "xyz"))
+			},
+			equals: "g.V().has(\"code\",within([\"abc\",\"xyz\"]))",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V("1", "2").Has("region", P.Within("US-TX", "US-GA"))
+			},
+			equals: "g.V(\"1\",\"2\").has(\"region\",within([\"US-TX\",\"US-GA\"]))",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().And(T__.Has("runways", P.Gt(5)), T__.Has("region", "US-TX"))
+			},
+			equals: "g.V().and(__.has(\"runways\",gt(5)),__.has(\"region\",\"US-TX\"))",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().Union(T__.Has("runways", P.Gt(5)), T__.Has("region", "US-TX"))
+			},
+			equals: "g.V().union(__.has(\"runways\",gt(5)),__.has(\"region\",\"US-TX\"))",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V("3").Choose(T__.Values("runways").Is(3), T__.Constant("three"), T__.Constant("not three"))
+			},
+			equals: "g.V(\"3\").choose(__.values(\"runways\").is(3),__.constant(\"three\"),__.constant(\"not three\"))",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V("3").Choose(T__.Values("runways")).Option(1, T__.Constant("three")).Option(2, T__.Constant("not three"))
+			},
+			equals: "g.V(\"3\").choose(__.values(\"runways\")).option(1,__.constant(\"three\")).option(2,__.constant(\"not three\"))",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V("3").Choose(T__.Values("runways")).Option(1.5, T__.Constant("one and a half")).Option(2, T__.Constant("not three"))
+			},
+			equals: "g.V(\"3\").choose(__.values(\"runways\")).option(1.5D,__.constant(\"one and a half\")).option(2,__.constant(\"not three\"))",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V("3").Repeat(T__.Out().SimplePath()).Until(T__.Loops().Is(1)).Count()
+			},
+			equals: "g.V(\"3\").repeat(__.out().simplePath()).until(__.loops().is(1)).count()",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().HasLabel("airport").Limit(20).Group().By("region").By("code").Order(Scope.Local).By(Column.Keys)
+			},
+			equals: "g.V().hasLabel(\"airport\").limit(20).group().by(\"region\").by(\"code\").order(Scope.local).by(Column.keys)",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V("1").As("a").V("2").As("a").Select(Pop.All, "a")
+			},
+			equals: "g.V(\"1\").as(\"a\").V(\"2\").as(\"a\").select(Pop.all,\"a\")",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.AddV("test").Property(Cardinality.Set, "p1", 10)
+			},
+			equals: "g.addV(\"test\").property(Cardinality.set,\"p1\",10)",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.AddV("test").Property(Cardinality.List, "p1", 10)
+			},
+			equals: "g.addV(\"test\").property(Cardinality.list,\"p1\",10)",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.AddV("test").Property(Cardinality.Single, "p1", 10)
+			},
+			equals: "g.addV(\"test\").property(Cardinality.single,\"p1\",10)",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().Limit(5).Order().By(T__.Label())
+			},
+			equals: "g.V().limit(5).order().by(__.label())",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().Range(1, 5)
+			},
+			equals: "g.V().range(1,5)",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.AddV("test").Property("p1", 123)
+			},
+			equals: "g.addV(\"test\").property(\"p1\",123)",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().Has("date", P.Gt(time.Date(2021, 1, 1, 9, 30, 0, 0, time.UTC)))
+			},
+			equals: "g.V().has(\"date\",gt(datetime(\"2021-01-01T09:30:00Z\")))",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.AddE("route").From(T__.V("1")).To(T__.V("2"))
+			},
+			equals: "g.addE(\"route\").from(__.V(\"1\")).to(__.V(\"2\"))",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.WithSideEffect("a", []interface{}{1, 2}).V("3").Select("a")
+			},
+			equals: "g.withSideEffect(\"a\",[1,2]).V(\"3\").select(\"a\")",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.WithSideEffect("a", 1).V("3").Select("a")
+			},
+			equals: "g.withSideEffect(\"a\",1).V(\"3\").select(\"a\")",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.WithSideEffect("a", "abc").V("3").Select("a")
+			},
+			equals: "g.withSideEffect(\"a\",\"abc\").V(\"3\").select(\"a\")",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().Has("airport", "region", "US-NM").Limit(3).Values("elev").Fold().Index()
+			},
+			equals: "g.V().has(\"airport\",\"region\",\"US-NM\").limit(3).values(\"elev\").fold().index()",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V("3").Repeat(T__.TimeLimit(1000).Out().SimplePath()).Until(T__.Has("code", "AGR")).Path()
+			},
+			equals: "g.V(\"3\").repeat(__.timeLimit(1000).out().simplePath()).until(__.has(\"code\",\"AGR\")).path()",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().HasLabel("airport").Where(T__.Values("elev").Is(P.Gt(14000)))
+			},
+			equals: "g.V().hasLabel(\"airport\").where(__.values(\"elev\").is(gt(14000)))",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().HasLabel("airport").Where(T__.Out().Count().Is(P.Gt(250))).Values("code")
+			},
+			equals: "g.V().hasLabel(\"airport\").where(__.out().count().is(gt(250))).values(\"code\")",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().HasLabel("airport").Filter(T__.Out().Count().Is(P.Gt(250))).Values("code")
+			},
+			equals: "g.V().hasLabel(\"airport\").filter(__.out().count().is(gt(250))).values(\"code\")",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.WithSack(0).
+					V("3").
+					Repeat(T__.OutE("route").Sack(Operator.Sum).By("dist").InV()).
+					Until(T__.Has("code", "AGR").Or().Loops().Is(4)).
+					Has("code", "AGR").
+					Local(T__.Union(T__.Path().By("code").By("dist"), T__.Sack()).Fold()).
+					Limit(10)
+			},
+			equals: "g.withSack(0).V(\"3\").repeat(__.outE(\"route\").sack(Operator.sum).by(\"dist\").inV()).until(__.has(\"code\",\"AGR\").or().loops().is(4)).has(\"code\",\"AGR\").local(__.union(__.path().by(\"code\").by(\"dist\"),__.sack()).fold()).limit(10)",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.AddV().As("a").AddV().As("b").AddE("knows").From("a").To("b")
+			},
+			equals: "g.addV().as(\"a\").addV().as(\"b\").addE(\"knows\").from(\"a\").to(\"b\")",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.AddV("Person").As("a").AddV("Person").As("b").AddE("knows").From("a").To("b")
+			},
+			equals: "g.addV(\"Person\").as(\"a\").addV(\"Person\").as(\"b\").addE(\"knows\").from(\"a\").to(\"b\")",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V("3").Project("Out", "In").By(T__.Out().Count()).By(T__.In().Count())
+			},
+			equals: "g.V(\"3\").project(\"Out\",\"In\").by(__.out().count()).by(__.in().count())",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V("44").Out().Aggregate("a").Out().Where(P.Within("a")).Path()
+			},
+			equals: "g.V(\"44\").out().aggregate(\"a\").out().where(within(\"a\")).path()",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().Has("date", time.Date(2021, 2, 22, 0, 0, 0, 0, time.UTC))
+			},
+			equals: "g.V().has(\"date\",datetime(\"2021-02-22T00:00:00Z\"))",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().Has("date", P.Within(time.Date(2021, 2, 22, 0, 0, 0, 0, time.UTC), time.Date(2021, 1, 1, 0, 0, 0, 0, time.UTC)))
+			},
+			equals: "g.V().has(\"date\",within([datetime(\"2021-02-22T00:00:00Z\"),datetime(\"2021-01-01T00:00:00Z\")]))",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().Has("date", P.Between(time.Date(2021, 1, 1, 0, 0, 0, 0, time.UTC), time.Date(2021, 2, 22, 0, 0, 0, 0, time.UTC)))
+			},
+			equals: "g.V().has(\"date\",between(datetime(\"2021-01-01T00:00:00Z\"),datetime(\"2021-02-22T00:00:00Z\")))",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().Has("date", P.Inside(time.Date(2021, 1, 1, 0, 0, 0, 0, time.UTC), time.Date(2021, 2, 22, 0, 0, 0, 0, time.UTC)))
+			},
+			equals: "g.V().has(\"date\",inside(datetime(\"2021-01-01T00:00:00Z\"),datetime(\"2021-02-22T00:00:00Z\")))",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().Has("date", P.Gt(time.Date(2021, 1, 1, 9, 30, 0, 0, time.UTC)))
+			},
+			equals: "g.V().has(\"date\",gt(datetime(\"2021-01-01T09:30:00Z\")))",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().Has("runways", P.Between(3, 5))
+			},
+			equals: "g.V().has(\"runways\",between(3,5))",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().Has("runways", P.Inside(3, 5))
+			},
+			equals: "g.V().has(\"runways\",inside(3,5))",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V("44").OutE().ElementMap()
+			},
+			equals: "g.V(\"44\").outE().elementMap()",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V("44").ValueMap().By(T__.Unfold())
+			},
+			equals: "g.V(\"44\").valueMap().by(__.unfold())",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V("44").ValueMap().With(WithOptions.Tokens, WithOptions.Labels)
+			},
+			equals: "g.V(\"44\").valueMap().with(\"~tinkerpop.valueMap.tokens\",2)",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V("44").ValueMap().With(WithOptions.All)
+			},
+			equals: "g.V(\"44\").valueMap().with(15)",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V("44").ValueMap().With(WithOptions.Indexer)
+			},
+			equals: "g.V(\"44\").valueMap().with(\"~tinkerpop.index.indexer\")",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V("44").ValueMap().With(WithOptions.Tokens)
+			},
+			equals: "g.V(\"44\").valueMap().with(\"~tinkerpop.valueMap.tokens\")",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.WithStrategies(ReadOnlyStrategy()).AddV("test")
+			},
+			equals: "g.withStrategies(ReadOnlyStrategy).addV(\"test\")",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.WithStrategies(SubgraphStrategy(SubgraphStrategyConfig{Vertices: T__.Has("region", "US-TX"), Edges: T__.HasLabel("route")})).V().Count()
+			},
+			containsRandomClassParams: true,
+			equals:                    "g.withStrategies(new SubgraphStrategy(vertices:__.has(\"region\",\"US-TX\"),edges:__.hasLabel(\"route\"))).V().count()",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.WithStrategies(SubgraphStrategy(SubgraphStrategyConfig{VertexProperties: T__.HasNot("runways")})).V().Count()
+			},
+			equals: "g.withStrategies(new SubgraphStrategy(vertexProperties:__.hasNot(\"runways\"))).V().count()",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.WithStrategies(SubgraphStrategy(SubgraphStrategyConfig{Vertices: T__.Has("region", "US-TX"), VertexProperties: T__.HasNot("runways")})).V().Count()
+			},
+			containsRandomClassParams: true,
+			equals:                    "g.withStrategies(new SubgraphStrategy(vertices:__.has(\"region\",\"US-TX\"),vertexProperties:__.hasNot(\"runways\"))).V().count()",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.WithStrategies(ReadOnlyStrategy(), SubgraphStrategy(SubgraphStrategyConfig{Vertices: T__.Has("region", "US-TX"), Edges: T__.HasLabel("route")})).V().Count()
+			},
+			containsRandomClassParams: true,
+			equals:                    "g.withStrategies(ReadOnlyStrategy,new SubgraphStrategy(vertices:__.has(\"region\",\"US-TX\"),edges:__.hasLabel(\"route\"))).V().count()",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.WithStrategies(ReadOnlyStrategy(), SubgraphStrategy(SubgraphStrategyConfig{Vertices: T__.Has("region", "US-TX")})).V().Count()
+			},
+			equals: "g.withStrategies(ReadOnlyStrategy,new SubgraphStrategy(vertices:__.has(\"region\",\"US-TX\"))).V().count()",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.WithStrategies(OptionsStrategy(map[string]interface{}{"evaluationTimeout": 500})).V().Count()
+			},
+			// OptionsStrategy are now extracted into request message and is no longer sent with the script
+			equals: "g.V().count()",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.WithStrategies(PartitionStrategy(PartitionStrategyConfig{PartitionKey: "partition", WritePartition: "a", ReadPartitions: NewSimpleSet("a")})).AddV("test")
+			},
+			containsRandomClassParams: true,
+			equals:                    "g.withStrategies(new PartitionStrategy(includeMetaProperties:false,partitionKey:\"partition\",writePartition:\"a\",readPartitions:[\"a\"])).addV(\"test\")",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.WithStrategies(VertexProgramStrategy(VertexProgramStrategyConfig{})).V().ShortestPath().With("~tinkerpop.shortestPath.target", T__.Has("name", "peter"))
+			},
+			equals: "g.withStrategies(VertexProgramStrategy).V().shortestPath().with(\"~tinkerpop.shortestPath.target\",__.has(\"name\",\"peter\"))",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().Has("p1", TextP.StartingWith("foo"))
+			},
+			equals: "g.V().has(\"p1\",startingWith(\"foo\"))",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().Has("p1", TextP.EndingWith("foo"))
+			},
+			equals: "g.V().has(\"p1\",endingWith(\"foo\"))",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().Has("p1", TextP.Containing("foo"))
+			},
+			equals: "g.V().has(\"p1\",containing(\"foo\"))",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().Has("p1", nil)
+			},
+			equals: "g.V().has(\"p1\",null)",
+		},
+	}
+
+	var testsToRun []test
+
+	onlyTests := make([]test, 0)
+	for _, tt := range tests {
+		if tt.only {
+			onlyTests = append(onlyTests, tt)
+		}
+	}
+
+	if len(onlyTests) > 0 {
+		testsToRun = onlyTests
+	} else {
+		testsToRun = tests
+	}
+
+	for _, tt := range testsToRun {
+		if tt.skip {
+			continue
+		}
+
+		testName := tt.name
+		if testName == "" {
+			testName = tt.equals
+		}
+
+		t.Run(testName, func(t *testing.T) {
+			g := NewGraphTraversalSource(nil, nil)
+			gremlinLang := tt.assert(g).GremlinLang.GetGremlin()
+			if !tt.containsRandomClassParams && gremlinLang != tt.equals {
+				t.Errorf("GremlinLang = %v, equals %v", gremlinLang, tt.equals)
+			}
+			if tt.containsRandomClassParams {
+				equalsParams := getArgs(tt.equals)
+				gotParams := getArgs(gremlinLang)
+
+				if len(equalsParams) != len(gotParams) {
+					t.Errorf("GremlinLang = %v, equals %v", gremlinLang, tt.equals)
+				}
+
+				for _, equalsParam := range equalsParams {
+					found := false
+					for _, gotParam := range gotParams {
+						if equalsParam == gotParam {
+							found = true
+							break
+						}
+					}
+					if !found {
+						t.Errorf("translator.Translate() = %v, equals %v", gremlinLang, tt.equals)
+					}
+				}
+			}
+		})
+	}
+}
+
+func getArgs(result string) []string {
+	pattern := `(\w+:.*?)`
+	re := regexp.MustCompile(pattern)
+	matches := re.FindAllStringSubmatch(result, -1)
+
+	params := make([]string, 0)
+	for _, match := range matches {
+		if len(match) > 0 {
+			params = append(params, match[0])
+		}
+	}
+
+	return params
+}
diff --git a/gremlin-go/driver/httpProtocol.go b/gremlin-go/driver/httpProtocol.go
new file mode 100644
index 0000000000..844b73fee1
--- /dev/null
+++ b/gremlin-go/driver/httpProtocol.go
@@ -0,0 +1,154 @@
+/*
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements.  See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership.  The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License.  You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+*/
+
+package gremlingo
+
+import (
+	"fmt"
+	"net/http"
+)
+
+// responsible for serializing and sending requests and then receiving and deserializing responses
+type httpProtocol struct {
+	serializer   serializer
+	logHandler   *logHandler
+	url          string
+	connSettings *connectionSettings
+	httpClient   *http.Client
+}
+
+func newHttpProtocol(handler *logHandler, url string, connSettings *connectionSettings) *httpProtocol {
+	transport := &http.Transport{
+		TLSClientConfig:    connSettings.tlsConfig,
+		MaxConnsPerHost:    0, // TODO
+		IdleConnTimeout:    0, // TODO
+		DisableCompression: !connSettings.enableCompression,
+	}
+
+	httpClient := http.Client{
+		Transport: transport,
+		Timeout:   connSettings.connectionTimeout,
+	}
+
+	httpProt := &httpProtocol{
+		serializer:   newGraphBinarySerializer(handler),
+		logHandler:   handler,
+		url:          url,
+		connSettings: connSettings,
+		httpClient:   &httpClient,
+	}
+	return httpProt
+}
+
+// sends a query request and returns a ResultSet that can be used to obtain query results
+func (protocol *httpProtocol) send(request *request) (ResultSet, error) {
+	rs := newChannelResultSet()
+	fmt.Println("Serializing request")
+	bytes, err := protocol.serializer.serializeMessage(request)
+	if err != nil {
+		rs.setError(err)
+		rs.Close()
+		return rs, err
+	}
+
+	// one transport per request
+	transport := NewHttpTransporter(protocol.url, protocol.connSettings, protocol.httpClient, protocol.logHandler)
+
+	// async send request
+	transport.wg.Add(1)
+	go func() {
+		defer transport.wg.Done()
+		err := transport.Write(bytes)
+		if err != nil {
+			rs.setError(err)
+			rs.Close()
+		}
+	}()
+
+	// async receive response
+	transport.wg.Add(1)
+	go func() {
+		defer transport.wg.Done()
+		msg, err := transport.Read()
+		if err != nil {
+			rs.setError(err)
+			rs.Close()
+		} else {
+			err = protocol.receive(rs, msg)
+		}
+		transport.Close()
+	}()
+
+	return rs, err
+}
+
+// receives a binary response message, deserializes, and adds results to the ResultSet
+func (protocol *httpProtocol) receive(rs ResultSet, msg []byte) error {
+	fmt.Println("Deserializing response")
+	resp, err := protocol.serializer.deserializeMessage(msg)
+	if err != nil {
+		protocol.logHandler.logf(Error, logErrorGeneric, "receive()", err.Error())
+		rs.Close()
+		return err
+	}
+
+	fmt.Println("Handling response")
+	err = protocol.handleResponse(rs, resp)
+	if err != nil {
+		protocol.logHandler.logf(Error, logErrorGeneric, "receive()", err.Error())
+		rs.Close()
+		return err
+	}
+	return nil
+}
+
+// processes a deserialized response and attempts to add results to the ResultSet
+func (protocol *httpProtocol) handleResponse(rs ResultSet, response response) error {
+	fmt.Println("Handling response")
+
+	statusCode, data := response.responseStatus.code, response.responseResult.data
+	if rs == nil {
+		return newError(err0501ResponseHandlerResultSetNotCreatedError)
+	}
+
+	if statusCode == http.StatusNoContent {
+		rs.addResult(&Result{make([]interface{}, 0)})
+		rs.Close()
+		protocol.logHandler.logf(Debug, readComplete)
+	} else if statusCode == http.StatusOK {
+		rs.addResult(&Result{data})
+		rs.Close()
+		protocol.logHandler.logf(Debug, readComplete)
+	} else if statusCode == http.StatusUnauthorized || statusCode == http.StatusForbidden {
+		rs.Close()
+		err := newError(err0503ResponseHandlerAuthError, response.responseStatus, response.responseResult)
+		rs.setError(err)
+		return err
+	} else {
+		rs.Close()
+		err := newError(err0502ResponseHandlerReadLoopError, response.responseStatus, statusCode)
+		rs.setError(err)
+		return err
+	}
+	return nil
+}
+
+func (protocol *httpProtocol) close() {
+	protocol.httpClient.CloseIdleConnections()
+}
diff --git a/gremlin-go/driver/httpTransporter.go b/gremlin-go/driver/httpTransporter.go
index ed8ca7f18f..f11cc104e1 100644
--- a/gremlin-go/driver/httpTransporter.go
+++ b/gremlin-go/driver/httpTransporter.go
@@ -22,19 +22,20 @@ package gremlingo
 import (
 	"bytes"
 	"compress/zlib"
-	"encoding/json"
+	"encoding/hex"
 	"errors"
+	"fmt"
 	"io"
 	"net/http"
+	"os"
 	"sync"
 )
 
 // TODO decide channel size when chunked response handling is implemented - for now just set to 1
 const responseChannelSizeDefault = 1
-const contentTypeHeader = "content-type"
 
-// httpTransporter responsible for sending and receiving bytes to/from the server
-type httpTransporter struct {
+// HttpTransporter responsible for sending and receiving bytes to/from the server
+type HttpTransporter struct {
 	url             string
 	isClosed        bool
 	connSettings    *connectionSettings
@@ -44,10 +45,10 @@ type httpTransporter struct {
 	logHandler      *logHandler
 }
 
-func newHttpTransporter(url string, connSettings *connectionSettings, httpClient *http.Client, logHandler *logHandler) *httpTransporter {
+func NewHttpTransporter(url string, connSettings *connectionSettings, httpClient *http.Client, logHandler *logHandler) *HttpTransporter {
 	wg := &sync.WaitGroup{}
 
-	return &httpTransporter{
+	return &HttpTransporter{
 		url:             url,
 		connSettings:    connSettings,
 		responseChannel: make(chan []byte, responseChannelSizeDefault),
@@ -57,115 +58,74 @@ func newHttpTransporter(url string, connSettings *connectionSettings, httpClient
 	}
 }
 
-// write sends bytes to the server as a POST request and sends received response bytes to the responseChannel
-func (transporter *httpTransporter) write(data []byte) error {
-	resp, err := transporter.sendRequest(data)
-	if err != nil {
-		return err
-	}
-
-	respBytes, err := transporter.readResponse(resp)
+// Write sends bytes to the server as a POST request and sends received response bytes to the responseChannel
+func (transporter *HttpTransporter) Write(data []byte) error {
+	req, err := http.NewRequest("POST", transporter.url, bytes.NewBuffer(data))
 	if err != nil {
+		transporter.logHandler.logf(Error, failedToSendRequest, err.Error())
 		return err
 	}
-
-	// possible to receive graph-binary or json error response bodies
-	if resp.StatusCode != 200 && resp.Header.Get(contentTypeHeader) != graphBinaryMimeType {
-		return transporter.createResponseError(respBytes, resp)
-	}
-
-	transporter.responseChannel <- respBytes
-	return nil
-}
-
-// read reads bytes from the responseChannel
-func (transporter *httpTransporter) read() ([]byte, error) {
-	msg, ok := <-transporter.responseChannel
-	if !ok {
-		return []byte{}, errors.New("failed to read from response channel")
+	req.Header.Set("content-type", graphBinaryMimeType)
+	req.Header.Set("accept", graphBinaryMimeType)
+	if transporter.connSettings.enableUserAgentOnConnect {
+		req.Header.Set(userAgentHeader, userAgent)
 	}
-	return msg, nil
-}
-
-// close closes the transporter and its corresponding responseChannel
-func (transporter *httpTransporter) close() {
-	if !transporter.isClosed {
-		if transporter.responseChannel != nil {
-			close(transporter.responseChannel)
-		}
-		transporter.isClosed = true
+	if transporter.connSettings.enableCompression {
+		req.Header.Set("accept-encoding", "deflate")
 	}
-}
 
-func (transporter *httpTransporter) createResponseError(respBytes []byte, resp *http.Response) error {
-	contentType := resp.Header.Get(contentTypeHeader)
-	if contentType == "application/json" {
-		var jsonMap map[string]interface{}
-		err := json.Unmarshal(respBytes, &jsonMap)
-		if err != nil {
-			return err
-		}
-		message, exists := jsonMap["message"]
-		if exists {
-			return newError(err0502ResponseHandlerError, message, resp.StatusCode)
-		}
-		return newError(err0502ResponseHandlerError, "Response was not successful", resp.StatusCode)
+	fmt.Println("Sending request")
+	resp, err := transporter.httpClient.Do(req)
+	if err != nil {
+		transporter.logHandler.logf(Error, failedToSendRequest, err.Error())
+		return err
 	}
-	// unexpected error content type
-	return newError(err0502ResponseHandlerError, "Response was not successful and of unexpected content-type: "+contentType, resp.StatusCode)
-}
-
-// reads bytes from the given response
-func (transporter *httpTransporter) readResponse(resp *http.Response) ([]byte, error) {
-	var reader io.ReadCloser
-	var err error
 
+	reader := resp.Body
 	if resp.Header.Get("content-encoding") == "deflate" {
 		reader, err = zlib.NewReader(resp.Body)
 		if err != nil {
 			transporter.logHandler.logf(Error, failedToReceiveResponse, err.Error())
-			return nil, err
+			return err
 		}
-	} else {
-		reader = resp.Body
 	}
 
 	// TODO handle chunked encoding and send chunks to responseChannel
 	all, err := io.ReadAll(reader)
 	if err != nil {
 		transporter.logHandler.logf(Error, failedToReceiveResponse, err.Error())
-		return nil, err
+		return err
 	}
 	err = reader.Close()
 	if err != nil {
-		return nil, err
+		return err
 	}
-	transporter.logHandler.log(Debug, receivedResponse)
-	return all, nil
+
+	str := hex.EncodeToString(all)
+	_, _ = fmt.Fprintf(os.Stdout, "Received response data : %s\n", str)
+
+	fmt.Println("Sending response to responseChannel")
+	transporter.responseChannel <- all
+	return nil
 }
 
-// sends a POST request for the given byte content
-func (transporter *httpTransporter) sendRequest(data []byte) (*http.Response, error) {
-	transporter.logHandler.logf(Debug, creatingRequest)
-	req, err := http.NewRequest("POST", transporter.url, bytes.NewBuffer(data))
-	if err != nil {
-		transporter.logHandler.logf(Error, failedToSendRequest, err.Error())
-		return nil, err
-	}
-	req.Header.Set(contentTypeHeader, graphBinaryMimeType)
-	req.Header.Set("accept", graphBinaryMimeType)
-	if transporter.connSettings.enableUserAgentOnConnect {
-		req.Header.Set(userAgentHeader, userAgent)
-	}
-	if transporter.connSettings.enableCompression {
-		req.Header.Set("accept-encoding", "deflate")
+// Read reads bytes from the responseChannel
+func (transporter *HttpTransporter) Read() ([]byte, error) {
+	fmt.Println("Reading from responseChannel")
+	msg, ok := <-transporter.responseChannel
+	if !ok {
+		return []byte{}, errors.New("failed to read from response channel")
 	}
+	return msg, nil
+}
 
-	transporter.logHandler.logf(Debug, writeRequest)
-	resp, err := transporter.httpClient.Do(req)
-	if err != nil {
-		transporter.logHandler.logf(Error, failedToSendRequest, err.Error())
-		return nil, err
+// Close closes the transporter and its corresponding responseChannel
+func (transporter *HttpTransporter) Close() {
+	fmt.Println("Closing http transporter")
+	if !transporter.isClosed {
+		if transporter.responseChannel != nil {
+			close(transporter.responseChannel)
+		}
+		transporter.isClosed = true
 	}
-	return resp, nil
 }
diff --git a/gremlin-go/driver/logger.go b/gremlin-go/driver/logger.go
index 6297afef38..eef29f9b07 100644
--- a/gremlin-go/driver/logger.go
+++ b/gremlin-go/driver/logger.go
@@ -103,13 +103,16 @@ const (
 	nullInput                    errorKey = "NULL_INPUT"
 	unexpectedNull               errorKey = "UNEXPECTED_NULL_VALUE"
 	writeRequest                 errorKey = "WRITE_REQUEST"
+	errorCallback                errorKey = "ERROR_CALLBACK"
 	creatingRequest              errorKey = "CREATING_REQUEST"
 	readComplete                 errorKey = "READ_COMPLETE"
 	submitStartedString          errorKey = "SUBMIT_STARTED_STRING"
 	submitStartedBytecode        errorKey = "SUBMIT_STARTED_BYTECODE"
+	failedToCloseInErrorCallback errorKey = "FAILED_TO_CLOSE_IN_ERROR_CALLBACK"
+	failedToWriteMessage         errorKey = "FAILED_TO_WRITE_MESSAGE"
+	failedToSetWriteDeadline     errorKey = "FAILED_TO_SET_WRITE_DEADLINE"
 	failedToReceiveResponse      errorKey = "FAILED_TO_RECEIVE_RESPONSE"
 	failedToSendRequest          errorKey = "FAILED_TO_SEND_REQUEST"
-	receivedResponse   			 errorKey = "RECEIVED_RESPONSE"
 	logErrorGeneric              errorKey = "LOG_ERROR_GENERIC"
 	closeDriverRemoteConnection  errorKey = "CLOSE_DRIVER_REMOTE_CONNECTION"
 	closeClient                  errorKey = "CLOSE_CLIENT"
diff --git a/gremlin-go/driver/transporter.go b/gremlin-go/driver/marker.go
similarity index 65%
rename from gremlin-go/driver/transporter.go
rename to gremlin-go/driver/marker.go
index 11d65f5e73..bb6e855bf5 100644
--- a/gremlin-go/driver/transporter.go
+++ b/gremlin-go/driver/marker.go
@@ -19,22 +19,28 @@ under the License.
 
 package gremlingo
 
-import "time"
-
-type transporter interface {
-	Connect() error
-	Write(data []byte) error
-	Read() ([]byte, error)
-	Close() error
-	IsClosed() bool
-	getAuthInfo() AuthInfoProvider
+import "fmt"
+
+// Marker is used in response
+type Marker interface {
+	GetValue() byte
+}
+
+type marker struct {
+	value byte
+}
+
+func EndOfStream() Marker {
+	return marker{byte(0)}
+}
+
+func (m marker) GetValue() byte {
+	return m.value
 }
 
-type websocketConn interface {
-	WriteMessage(int, []byte) error
-	ReadMessage() (int, []byte, error)
-	SetPongHandler(h func(appData string) error)
-	Close() error
-	SetReadDeadline(t time.Time) error
-	SetWriteDeadline(t time.Time) error
+func Of(value byte) (Marker, error) {
+	if value != 0 {
+		return nil, fmt.Errorf("marker value erorr")
+	}
+	return EndOfStream(), nil
 }
diff --git a/gremlin-go/driver/request.go b/gremlin-go/driver/request.go
index 79581b959e..42e8e4716a 100644
--- a/gremlin-go/driver/request.go
+++ b/gremlin-go/driver/request.go
@@ -118,7 +118,7 @@ func extractWithStrategiesReqArgs(insn instruction) map[string]interface{} {
 			continue
 		}
 
-		if strategy.name != decorationNamespace+"OptionsStrategy" {
+		if strategy.name != "OptionsStrategy" {
 			continue
 		}
 
diff --git a/gremlin-go/driver/resources/logger-messages/en.json b/gremlin-go/driver/resources/logger-messages/en.json
index d024444ed6..82bdce46a3 100644
--- a/gremlin-go/driver/resources/logger-messages/en.json
+++ b/gremlin-go/driver/resources/logger-messages/en.json
@@ -15,7 +15,10 @@
   "LOG_ERROR_GENERIC": "Error occurred during operation %s: '%s'",
   "CLOSE_DRIVER_REMOTE_CONNECTION": "Closing DriverRemoteConnection with url '%s'",
   "CLOSE_CLIENT": "Closing Client with url '%s'",
+  "ERROR_CLOSING_CONNECTION": "Ignoring error closing connection: %s",
+  "CREATE_CONNECTION_ERROR": "Error creating new connection for connection pool: %s",
+  "POOL_NEW_CONNECTION_ERROR": "Falling back to least-used connection. Creating new connection due to least-used connection exceeding concurrent usage threshold failed: %s",
+  "POOL_INITIAL_EXCEEDS_MAXIMUM": "InitialConcurrentConnections setting %d exceeded MaximumConcurrentConnections setting %d - limiting InitialConcurrentConnections to %d.",
   "FAILED_TO_RECEIVE_RESPONSE": "Failed to receive response: %s",
-  "FAILED_TO_SEND_REQUEST": "Failed to send request: %s",
-  "RECEIVED_RESPONSE": "Received response data"
+  "FAILED_TO_SEND_REQUEST": "Failed to send request: %s"
 }
diff --git a/gremlin-go/driver/response.go b/gremlin-go/driver/response.go
index dfe89ac07f..c147acf249 100644
--- a/gremlin-go/driver/response.go
+++ b/gremlin-go/driver/response.go
@@ -19,8 +19,6 @@ under the License.
 
 package gremlingo
 
-import "github.com/google/uuid"
-
 // responseStatus contains the status info of the response.
 type responseStatus struct {
 	code      uint32
@@ -35,7 +33,6 @@ type responseResult struct {
 
 // response represents a response from the server.
 type response struct {
-	responseID     uuid.UUID
 	responseStatus responseStatus
 	responseResult responseResult
 }
diff --git a/gremlin-go/driver/serializer.go b/gremlin-go/driver/serializer.go
index 7ef810ab53..5ef970a68f 100644
--- a/gremlin-go/driver/serializer.go
+++ b/gremlin-go/driver/serializer.go
@@ -22,6 +22,8 @@ package gremlingo
 import (
 	"bytes"
 	"encoding/binary"
+	"fmt"
+	"os"
 	"sync"
 )
 
@@ -61,6 +63,7 @@ func newGraphBinarySerializer(handler *logHandler) serializer {
 	return graphBinarySerializer{&serializer}
 }
 
+// TODO change for graph binary 4.0 version is finalized
 const versionByte byte = 0x81
 
 // serializeMessage serializes a request message into GraphBinary.
@@ -108,16 +111,18 @@ func (gs graphBinarySerializer) deserializeMessage(message []byte) (response, er
 		if err != nil {
 			return msg, err
 		}
+		_, _ = fmt.Fprintf(os.Stdout, "Deserializing data : %v\n", n)
+		if n == EndOfStream() {
+			break
+		}
 		results = append(results, n)
 	}
-	if len(results) == 1 {
-		// unwrap single results
-		msg.responseResult.data = results[0]
-	} else {
-		msg.responseResult.data = results
-	}
+	_, _ = fmt.Fprintf(os.Stdout, "Deserialized results : %s\n", results)
+	msg.responseResult.data = results
 	code := readUint32Safe(&message, &i)
 	msg.responseStatus.code = code
+	// TODO read status message
+	msg.responseStatus.message = "OK"
 	statusMsg, err := readUnqualified(&message, &i, stringType, true)
 	if err != nil {
 		return msg, err
@@ -137,7 +142,6 @@ func (gs graphBinarySerializer) deserializeMessage(message []byte) (response, er
 
 func initSerializers() {
 	serializers = map[dataType]writer{
-		bytecodeType:   bytecodeWriter,
 		stringType:     stringWriter,
 		bigDecimalType: bigDecimalWriter,
 		bigIntegerType: bigIntWriter,
@@ -164,37 +168,22 @@ func initSerializers() {
 			err := binary.Write(buffer, binary.BigEndian, value)
 			return buffer.Bytes(), err
 		},
-		vertexType:            vertexWriter,
-		edgeType:              edgeWriter,
-		propertyType:          propertyWriter,
-		vertexPropertyType:    vertexPropertyWriter,
-		lambdaType:            lambdaWriter,
-		traversalStrategyType: traversalStrategyWriter,
-		pathType:              pathWriter,
-		setType:               setWriter,
-		dateType:              timeWriter,
-		durationType:          durationWriter,
-		offsetDateTimeType:    offsetDateTimeWriter,
-		cardinalityType:       enumWriter,
-		columnType:            enumWriter,
-		directionType:         enumWriter,
-		dtType:                enumWriter,
-		gTypeType:             enumWriter,
-		operatorType:          enumWriter,
-		orderType:             enumWriter,
-		pickType:              enumWriter,
-		popType:               enumWriter,
-		tType:                 enumWriter,
-		barrierType:           enumWriter,
-		scopeType:             enumWriter,
-		mergeType:             enumWriter,
-		pType:                 pWriter,
-		textPType:             textPWriter,
-		bindingType:           bindingWriter,
-		mapType:               mapWriter,
-		listType:              listWriter,
-		byteBuffer:            byteBufferWriter,
-		classType:             classWriter,
+		vertexType:         vertexWriter,
+		edgeType:           edgeWriter,
+		propertyType:       propertyWriter,
+		vertexPropertyType: vertexPropertyWriter,
+		pathType:           pathWriter,
+		datetimeType:       timeWriter,
+		durationType:       durationWriter,
+		directionType:      enumWriter,
+		gTypeType:          enumWriter,
+		tType:              enumWriter,
+		mergeType:          enumWriter,
+		mapType:            mapWriter,
+		listType:           listWriter,
+		setType:            setWriter,
+		byteBuffer:         byteBufferWriter,
+		markerType:         markerWriter,
 	}
 }
 
@@ -213,39 +202,30 @@ func initDeserializers() {
 		stringType:     readString,
 
 		// Composite
-		listType:   readList,
+		//listType:   readList,
+		//setType:    readSet,
 		mapType:    readMap,
-		setType:    readSet,
 		uuidType:   readUuid,
 		byteBuffer: readByteBuffer,
-		classType:  readClass,
 
 		// Date Time
-		dateType:           timeReader,
-		timestampType:      timeReader,
-		offsetDateTimeType: offsetDateTimeReader,
-		durationType:       durationReader,
+		datetimeType: timeReader,
+		durationType: durationReader,
 
 		// Graph
-		traverserType:      traverserReader,
 		vertexType:         vertexReader,
 		edgeType:           edgeReader,
 		propertyType:       propertyReader,
 		vertexPropertyType: vertexPropertyReader,
 		pathType:           pathReader,
-		bulkSetType:        bulkSetReader,
 		tType:              enumReader,
 		directionType:      enumReader,
-		dtType:             enumReader,
 		gTypeType:          enumReader,
-		bindingType:        bindingReader,
-
-		// Metrics
-		metricsType:          metricsReader,
-		traversalMetricsType: traversalMetricsReader,
 
 		// Customer
 		customType: customTypeReader,
+
+		markerType: markerReader,
 	}
 	customDeserializers = map[string]CustomTypeReader{}
 }
diff --git a/gremlin-go/driver/serializer_test.go b/gremlin-go/driver/serializer_test.go
index 8bd16032f9..ad00f44df6 100644
--- a/gremlin-go/driver/serializer_test.go
+++ b/gremlin-go/driver/serializer_test.go
@@ -20,7 +20,6 @@ under the License.
 package gremlingo
 
 import (
-	"errors"
 	"fmt"
 	"testing"
 
@@ -28,14 +27,14 @@ import (
 	"golang.org/x/text/language"
 )
 
-const mapDataOrder1 = "[32 97 112 112 108 105 99 97 116 105 111 110 47 118 110 100 46 103 114 97 112 104 98 105 110 97 114 121 45 118 49 46 48 129 65 210 226 138 32 164 74 176 179 121 216 16 222 222 55 134 0 0 0 4 101 118 97 108 0 0 0 0 0 0 0 2 3 0 0 0 0 7 103 114 101 109 108 105 110 3 0 0 0 0 13 103 46 86 40 41 46 99 111 117 110 116 40 41 3 0 0 0 0 7 97 108 105 97 115 101 115 10 0 0 0 0 1 3 0 0 0 0 1 103 3 0 0 0 0 1 103]"
-const mapDataOrder2 = "[32 97 112 112 108 105 99 97 116 105 111 110 47 118 110 100 46 103 114 97 112 104 98 105 110 97 114 121 45 118 49 46 48 129 65 210 226 138 32 164 74 176 179 121 216 16 222 222 55 134 0 0 0 4 101 118 97 108 0 0 0 0 0 0 0 2 3 0 0 0 0 7 97 108 105 97 115 101 115 10 0 0 0 0 1 3 0 0 0 0 1 103 3 0 0 0 0 1 103 3 0 0 0 0 7 103 114 101 109 108 105 110 3 0 0 0 0 13 103 46 86 40 41 46 99 111 117 110 116 40 41]"
+const mapDataOrder1 = "[129 0 0 0 2 3 0 0 0 0 8 108 97 110 103 117 97 103 101 3 0 0 0 0 12 103 114 101 109 108 105 110 45 108 97 110 103 3 0 0 0 0 1 103 3 0 0 0 0 1 103 0 0 0 13 103 46 86 40 41 46 99 111 117 110 116 40 41]"
+const mapDataOrder2 = "[129 0 0 0 2 3 0 0 0 0 1 103 3 0 0 0 0 1 103 3 0 0 0 0 8 108 97 110 103 117 97 103 101 3 0 0 0 0 12 103 114 101 109 108 105 110 45 108 97 110 103 0 0 0 13 103 46 86 40 41 46 99 111 117 110 116 40 41]"
 
 func TestSerializer(t *testing.T) {
 	t.Run("test serialized request message", func(t *testing.T) {
 		testRequest := request{
 			gremlin: "g.V().count()",
-			fields: map[string]interface{}{"aliases": map[string]interface{}{"g": "g"}},
+			fields:  map[string]interface{}{"g": "g", "language": "gremlin-lang"},
 		}
 		serializer := newGraphBinarySerializer(newLogHandler(&defaultLogger{}, Error, language.English))
 		serialized, _ := serializer.serializeMessage(&testRequest)
@@ -46,76 +45,28 @@ func TestSerializer(t *testing.T) {
 	})
 
 	t.Run("test serialized response message", func(t *testing.T) {
-		responseByteArray := []byte{129, 0, 251, 37, 42, 74, 117, 221, 71, 191, 183, 78, 86, 53, 0, 12, 132, 100, 0, 0, 0, 200, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 0, 0, 0, 0, 4, 104, 111, 115, 116, 3, 0, 0, 0, 0, 16, 47, 49, 50, 55, 46, 48, 46, 48, 46, 49, 58, 54, 50, 48, 51, 53, 0, 0, 0, 0, 9, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+		// response of status code 200 with message OK and data of list of single item of integer zero
+		responseByteArray := []byte{129, 0, 1, 0, 0, 0, 0, 0, 253, 0, 0, 0, 0, 0, 200, 1, 1}
 		serializer := newGraphBinarySerializer(newLogHandler(&defaultLogger{}, Error, language.English))
 		response, err := serializer.deserializeMessage(responseByteArray)
 		assert.Nil(t, err)
-		assert.Equal(t, "fb252a4a-75dd-47bf-b74e-5635000c8464", response.responseID.String())
-		assert.Equal(t, uint16(200), response.responseStatus.code)
-		assert.Equal(t, "", response.responseStatus.message)
-		assert.Equal(t, []interface{}{int64(0)}, response.responseResult.data)
-	})
-
-	t.Run("test serialized response message w/ custom type", func(t *testing.T) {
-		RegisterCustomTypeReader("janusgraph.RelationIdentifier", exampleJanusgraphRelationIdentifierReader)
-		defer func() {
-			UnregisterCustomTypeReader("janusgraph.RelationIdentifier")
-		}()
-		responseByteArray := []byte{129, 0, 69, 222, 40, 55, 95, 62, 75, 249, 134, 133, 155, 133, 43, 151, 221, 68, 0, 0, 0, 200, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 0, 0, 0, 0, 4, 104, 111, 115, 116, 3, 0, 0, 0, 0, 18, 47, 49, 48, 46, 50, 52, 52, 46, 48, 46, 51, 51, 58, 53, 49, 52, 55, 48, 0, 0, 0, 0, 9, 0, 0, 0, 0, 1, 33, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 29, 106, 97, 110, 117, 115, 103, 114, 97, 112, 104, 46, 82, 101, 108, 97, 116, 105, 111, 110, 73, 100, 101, 110, 116, 105, 102, 105, 101, 1 [...]
-		serializer := newGraphBinarySerializer(newLogHandler(&defaultLogger{}, Error, language.English))
-		response, err := serializer.deserializeMessage(responseByteArray)
-		assert.Nil(t, err)
-		assert.Equal(t, "45de2837-5f3e-4bf9-8685-9b852b97dd44", response.responseID.String())
-		assert.Equal(t, uint16(200), response.responseStatus.code)
-		assert.Equal(t, "", response.responseStatus.message)
-		assert.NotNil(t, response.responseResult.data)
+		assert.Equal(t, uint32(200), response.responseStatus.code)
+		assert.Equal(t, "OK", response.responseStatus.message)
+		assert.Equal(t, []interface{}{int32(0)}, response.responseResult.data)
 	})
 }
 
 func TestSerializerFailures(t *testing.T) {
-	t.Run("test convertArgs failure", func(t *testing.T) {
+	t.Run("test serialize request fields failure", func(t *testing.T) {
+		invalid := "invalid"
 		testRequest := request{
-			// Invalid Input in fields, so should fail
-			fields: map[string]interface{}{"invalidInput": "invalidInput", "aliases": map[string]interface{}{"g": "g"}},
+			// Invalid pointer type in fields, so should fail
+			fields: map[string]interface{}{"invalidInput": &invalid, "g": "g"},
 		}
 		serializer := newGraphBinarySerializer(newLogHandler(&defaultLogger{}, Error, language.English))
 		resp, err := serializer.serializeMessage(&testRequest)
 		assert.Nil(t, resp)
 		assert.NotNil(t, err)
-		assert.True(t, isSameErrorCode(newError(err0704ConvertArgsNoSerializerError), err))
-	})
-
-	t.Run("test unkownCustomType failure", func(t *testing.T) {
-		responseByteArray := []byte{129, 0, 69, 222, 40, 55, 95, 62, 75, 249, 134, 133, 155, 133, 43, 151, 221, 68, 0, 0, 0, 200, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 0, 0, 0, 0, 4, 104, 111, 115, 116, 3, 0, 0, 0, 0, 18, 47, 49, 48, 46, 50, 52, 52, 46, 48, 46, 51, 51, 58, 53, 49, 52, 55, 48, 0, 0, 0, 0, 9, 0, 0, 0, 0, 1, 33, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 29, 106, 97, 110, 117, 115, 103, 114, 97, 112, 104, 46, 82, 101, 108, 97, 116, 105, 111, 110, 73, 100, 101, 110, 116, 105, 102, 105, 101, 1 [...]
-		serializer := newGraphBinarySerializer(newLogHandler(&defaultLogger{}, Error, language.English))
-		resp, err := serializer.deserializeMessage(responseByteArray)
-		// a partial message will still be returned
-		assert.NotNil(t, resp)
-		assert.NotNil(t, err)
-		assert.True(t, isSameErrorCode(newError(err0409GetSerializerToReadUnknownCustomTypeError), err))
+		assert.True(t, isSameErrorCode(newError(err0407GetSerializerToWriteUnknownTypeError), err))
 	})
 }
-
-// exampleJanusgraphRelationIdentifierReader this implementation is not complete and is used only for the purposes of testing custom readers
-func exampleJanusgraphRelationIdentifierReader(data *[]byte, i *int) (interface{}, error) {
-	const relationIdentifierType = 0x1001
-	const longMarker = 0
-
-	// expect type code
-	customDataTyp := readUint32Safe(data, i)
-	if customDataTyp != relationIdentifierType {
-		return nil, fmt.Errorf("unknown type code. got 0x%x, expected 0x%x", customDataTyp, relationIdentifierType)
-	}
-
-	// value flag, expect this to be non-nullable
-	if readByteSafe(data, i) != valueFlagNone {
-		return nil, errors.New("expected non-null value")
-	}
-
-	// outVertexId
-	if readByteSafe(data, i) == longMarker {
-		return readLongSafe(data, i), nil
-	} else {
-		return readString(data, i)
-	}
-}
diff --git a/gremlin-go/driver/strategies.go b/gremlin-go/driver/strategies.go
index e2887eb703..939f7ea741 100644
--- a/gremlin-go/driver/strategies.go
+++ b/gremlin-go/driver/strategies.go
@@ -19,20 +19,6 @@ under the License.
 
 package gremlingo
 
-const (
-	baseNamespace                 = "org.apache.tinkerpop.gremlin.process.traversal.strategy."
-	decorationNamespace           = baseNamespace + "decoration."
-	finalizationNamespace         = baseNamespace + "finalization."
-	optimizationNamespace         = baseNamespace + "optimization."
-	verificationNamespace         = baseNamespace + "verification."
-	computerDecorationNamespace   = "org.apache.tinkerpop.gremlin.process.computer.traversal.strategy.decoration."
-	computerVerificationNamespace = "org.apache.tinkerpop.gremlin.process.computer.traversal.strategy.verification."
-	// org.apache.tinkerpop.gremlin.process.computer.traversal.strategy.verification
-	// org.apache.tinkerpop.gremlin.process.traversal.strategy.verification
-	computerFinalizationNamespace = "org.apache.tinkerpop.gremlin.process.computer.traversal.strategy.finalization."
-	computerOptimizationNamespace = "org.apache.tinkerpop.gremlin.process.computer.traversal.strategy.optimization."
-)
-
 type TraversalStrategy interface {
 }
 
@@ -42,12 +28,17 @@ type traversalStrategy struct {
 	apply         func(g GraphTraversal)
 }
 
+// NewTraversalStrategy creates a new strategy with custom name and config
+func NewTraversalStrategy(name string, configuration map[string]interface{}) TraversalStrategy {
+	return &traversalStrategy{name: name, configuration: configuration}
+}
+
 // Decoration strategies
 
 // ConnectiveStrategy rewrites the binary conjunction form of a.And().b into a AndStep of
 // And(a,b) (likewise for OrStep).
 func ConnectiveStrategy() TraversalStrategy {
-	return &traversalStrategy{name: decorationNamespace + "ConnectiveStrategy"}
+	return &traversalStrategy{name: "ConnectiveStrategy"}
 }
 
 // ElementIdStrategy provides a degree of control over element identifier assignment as some Graphs don't provide
@@ -55,7 +46,7 @@ func ConnectiveStrategy() TraversalStrategy {
 // under the hood, thus simulating that capability.
 // By default, when an identifier is not supplied by the user, newly generated identifiers are UUID objects.
 func ElementIdStrategy() TraversalStrategy {
-	return &traversalStrategy{name: decorationNamespace + "ElementIdStrategy"}
+	return &traversalStrategy{name: "ElementIdStrategy"}
 }
 
 func HaltedTraverserStrategy(config ...HaltedTraverserStrategyConfig) TraversalStrategy {
@@ -65,7 +56,7 @@ func HaltedTraverserStrategy(config ...HaltedTraverserStrategyConfig) TraversalS
 			configMap["haltedTraverserFactory"] = config[0].HaltedTraverserFactory
 		}
 	}
-	return &traversalStrategy{name: decorationNamespace + "HaltedTraverserStrategy", configuration: configMap}
+	return &traversalStrategy{name: "HaltedTraverserStrategy", configuration: configMap}
 }
 
 // HaltedTraverserStrategyConfig provides configuration options for HaltedTraverserStrategy.
@@ -83,8 +74,7 @@ func OptionsStrategy(options ...map[string]interface{}) TraversalStrategy {
 	if len(options) > 0 {
 		optsMap = options[0]
 	}
-
-	return &traversalStrategy{name: decorationNamespace + "OptionsStrategy", configuration: optsMap}
+	return &traversalStrategy{name: "OptionsStrategy", configuration: options}
 }
 
 // PartitionStrategy partitions the Vertices, Edges and Vertex properties of a Graph into String named
@@ -101,7 +91,7 @@ func PartitionStrategy(config PartitionStrategyConfig) TraversalStrategy {
 	if len(config.ReadPartitions.ToSlice()) != 0 {
 		configMap["readPartitions"] = config.ReadPartitions
 	}
-	return &traversalStrategy{name: decorationNamespace + "PartitionStrategy", configuration: configMap}
+	return &traversalStrategy{name: "PartitionStrategy", configuration: configMap}
 }
 
 // PartitionStrategyConfig provides configuration options for PartitionStrategy.
@@ -125,8 +115,7 @@ func SeedStrategy(config ...SeedStrategyConfig) TraversalStrategy {
 	if len(config) > 0 {
 		configMap["seed"] = config[0].Seed
 	}
-
-	return &traversalStrategy{name: decorationNamespace + "SeedStrategy", configuration: configMap}
+	return &traversalStrategy{name: "SeedStrategy", configuration: configMap}
 }
 
 // SeedStrategyConfig provides configuration options for SeedStrategy. Zeroed (unset) values are used.
@@ -151,7 +140,7 @@ func SubgraphStrategy(config SubgraphStrategyConfig) TraversalStrategy {
 	if config.CheckAdjacentVertices != nil {
 		configMap["checkAdjacentVertices"] = config.CheckAdjacentVertices.(bool)
 	}
-	return &traversalStrategy{name: decorationNamespace + "SubgraphStrategy", configuration: configMap}
+	return &traversalStrategy{name: "SubgraphStrategy", configuration: configMap}
 }
 
 // SubgraphStrategyConfig provides configuration options for SubgraphStrategy. Zeroed (unset) values are ignored.
@@ -187,8 +176,7 @@ func VertexProgramStrategy(config ...VertexProgramStrategyConfig) TraversalStrat
 			configMap[k] = v
 		}
 	}
-
-	return &traversalStrategy{name: computerDecorationNamespace + "VertexProgramStrategy", configuration: configMap}
+	return &traversalStrategy{name: "VertexProgramStrategy", configuration: configMap}
 }
 
 // VertexProgramStrategyConfig provides configuration options for VertexProgramStrategy.
@@ -212,8 +200,7 @@ func MatchAlgorithmStrategy(config ...MatchAlgorithmStrategyConfig) TraversalStr
 			configMap["matchAlgorithm"] = config[0].MatchAlgorithm
 		}
 	}
-
-	return &traversalStrategy{name: finalizationNamespace + "MatchAlgorithmStrategy", configuration: configMap}
+	return &traversalStrategy{name: "MatchAlgorithmStrategy", configuration: configMap}
 }
 
 // MatchAlgorithmStrategyConfig provides configuration options for MatchAlgorithmStrategy.
@@ -222,22 +209,22 @@ type MatchAlgorithmStrategyConfig struct {
 	MatchAlgorithm string
 }
 
-func ReferenceElementStrategy() TraversalStrategy {
-	return &traversalStrategy{name: finalizationNamespace + "ReferenceElementStrategy"}
+func ReferenceElementStrategy(options ...map[string]interface{}) TraversalStrategy {
+	return &traversalStrategy{name: "ReferenceElementStrategy", configuration: options[0]}
 }
 
-func ComputerFinalizationStrategy() TraversalStrategy {
-	return &traversalStrategy{name: computerFinalizationNamespace + "ComputerFinalizationStrategy"}
+func ComputerFinalizationStrategy(options ...map[string]interface{}) TraversalStrategy {
+	return &traversalStrategy{name: "ComputerFinalizationStrategy", configuration: options[0]}
 }
 
-func ProfileStrategy() TraversalStrategy {
-	return &traversalStrategy{name: finalizationNamespace + "ProfileStrategy"}
+func ProfileStrategy(options ...map[string]interface{}) TraversalStrategy {
+	return &traversalStrategy{name: "ProfileStrategy", configuration: options[0]}
 }
 
 // Verification strategies
 
-func ComputerVerificationStrategy() TraversalStrategy {
-	return &traversalStrategy{name: verificationNamespace + "ComputerVerificationStrategy"}
+func ComputerVerificationStrategy(options ...map[string]interface{}) TraversalStrategy {
+	return &traversalStrategy{name: "ComputerVerificationStrategy", configuration: options[0]}
 }
 
 // EdgeLabelVerificationStrategy does not allow Edge traversal steps to have no label specified.
@@ -250,7 +237,7 @@ func EdgeLabelVerificationStrategy(config ...EdgeLabelVerificationStrategyConfig
 		configMap["throwException"] = config[0].ThrowException
 	}
 
-	return &traversalStrategy{name: verificationNamespace + "EdgeLabelVerificationStrategy", configuration: configMap}
+	return &traversalStrategy{name: "EdgeLabelVerificationStrategy", configuration: configMap}
 }
 
 // EdgeLabelVerificationStrategyConfig provides configuration options for EdgeLabelVerificationStrategy.
@@ -265,12 +252,12 @@ type EdgeLabelVerificationStrategyConfig struct {
 // about the traversal. This strategy is not activated by default. However, graph system providers may choose
 // to make this a default strategy in order to ensure their respective strategies are better able to operate.
 func LambdaRestrictionStrategy() TraversalStrategy {
-	return &traversalStrategy{name: verificationNamespace + "LambdaRestrictionStrategy"}
+	return &traversalStrategy{name: "LambdaRestrictionStrategy"}
 }
 
 // ReadOnlyStrategy detects steps marked with Mutating and returns an error if one is found.
 func ReadOnlyStrategy() TraversalStrategy {
-	return &traversalStrategy{name: verificationNamespace + "ReadOnlyStrategy"}
+	return &traversalStrategy{name: "ReadOnlyStrategy"}
 }
 
 // ReservedKeysVerificationStrategy detects property keys that should not be used by the traversal.
@@ -284,7 +271,7 @@ func ReservedKeysVerificationStrategy(config ...ReservedKeysVerificationStrategy
 			configMap["keys"] = config[0].Keys
 		}
 	}
-	return &traversalStrategy{name: verificationNamespace + "ReservedKeysVerificationStrategy", configuration: configMap}
+	return &traversalStrategy{name: "ReservedKeysVerificationStrategy", configuration: configMap}
 }
 
 // ReservedKeysVerificationStrategyConfig provides configuration options for ReservedKeysVerificationStrategy.
@@ -296,11 +283,19 @@ type ReservedKeysVerificationStrategyConfig struct {
 }
 
 func StandardVerificationStrategy() TraversalStrategy {
-	return &traversalStrategy{name: verificationNamespace + "StandardVerificationStrategy"}
+	return &traversalStrategy{name: "StandardVerificationStrategy"}
+}
+
+func VertexProgramRestrictionStrategy() TraversalStrategy {
+	return &traversalStrategy{name: "VertexProgramRestrictionStrategy"}
+}
+
+func StandardVerificationStrategy() TraversalStrategy {
+	return &traversalStrategy{name: "StandardVerificationStrategy"}
 }
 
 func VertexProgramRestrictionStrategy() TraversalStrategy {
-	return &traversalStrategy{name: computerVerificationNamespace + "VertexProgramRestrictionStrategy"}
+	return &traversalStrategy{name: "VertexProgramRestrictionStrategy"}
 }
 
 // Optimization strategies
@@ -313,20 +308,20 @@ func VertexProgramRestrictionStrategy() TraversalStrategy {
 // the Vertex on the other side of an Edge) can be satisfied by trips to incident Graph Elements (e.g. just the Edge
 // itself).
 func AdjacentToIncidentStrategy() TraversalStrategy {
-	return &traversalStrategy{name: optimizationNamespace + "AdjacentToIncidentStrategy"}
+	return &traversalStrategy{name: "AdjacentToIncidentStrategy"}
 }
 
 // ByModulatorOptimizationStrategy looks for standard traversals in By-modulators and replaces them with more
 // optimized traversals (e.g. TokenTraversal) if possible.
 func ByModulatorOptimizationStrategy() TraversalStrategy {
-	return &traversalStrategy{name: optimizationNamespace + "ByModulatorOptimizationStrategy"}
+	return &traversalStrategy{name: "ByModulatorOptimizationStrategy"}
 }
 
 // CountStrategy optimizes any occurrence of CountGlobalStep followed by an IsStep The idea is to limit
 // the number of incoming elements in a way that it's enough for the IsStep to decide whether it evaluates
 // true or false. If the traversal already contains a user supplied limit, the strategy won't modify it.
 func CountStrategy() TraversalStrategy {
-	return &traversalStrategy{name: optimizationNamespace + "CountStrategy"}
+	return &traversalStrategy{name: "CountStrategy"}
 }
 
 // EarlyLimitStrategy looks for RangeGlobalSteps that can be moved further left in the traversal and thus be applied
@@ -334,7 +329,7 @@ func CountStrategy() TraversalStrategy {
 // If the logical consequence of one or multiple RangeGlobalSteps is an empty result, the strategy will remove
 // as many steps as possible and add a NoneStep instead.
 func EarlyLimitStrategy() TraversalStrategy {
-	return &traversalStrategy{name: optimizationNamespace + "EarlyLimitStrategy"}
+	return &traversalStrategy{name: "EarlyLimitStrategy"}
 }
 
 // FilterRankingStrategy reorders filter- and order-steps according to their rank. Step ranks are defined within
@@ -342,18 +337,18 @@ func EarlyLimitStrategy() TraversalStrategy {
 // push step labels as far "right" as possible in order to keep Traversers as small and bulkable as possible prior to
 // the absolute need for Path-labeling.
 func FilterRankingStrategy() TraversalStrategy {
-	return &traversalStrategy{name: optimizationNamespace + "FilterRankingStrategy"}
+	return &traversalStrategy{name: "FilterRankingStrategy"}
 }
 
 func GraphFilterStrategy() TraversalStrategy {
-	return &traversalStrategy{name: computerOptimizationNamespace + "GraphFilterStrategy"}
+	return &traversalStrategy{name: "GraphFilterStrategy"}
 }
 
 // IdentityRemovalStrategy looks for IdentityStep instances and removes them.
 // If the identity step is labeled, its labels are added to the previous step.
 // If the identity step is labeled and it's the first step in the traversal, it stays.
 func IdentityRemovalStrategy() TraversalStrategy {
-	return &traversalStrategy{name: optimizationNamespace + "IdentityRemovalStrategy"}
+	return &traversalStrategy{name: "IdentityRemovalStrategy"}
 }
 
 // IncidentToAdjacentStrategy looks for .OutE().InV(), .InE().OutV() and .BothE().OtherV()
@@ -364,7 +359,7 @@ func IdentityRemovalStrategy() TraversalStrategy {
 //	the traversal contains a Path step
 //	the traversal contains a Lambda step
 func IncidentToAdjacentStrategy() TraversalStrategy {
-	return &traversalStrategy{name: optimizationNamespace + "IncidentToAdjacentStrategy"}
+	return &traversalStrategy{name: "IncidentToAdjacentStrategy"}
 }
 
 // InlineFilterStrategy analyzes filter-steps with child traversals that themselves are pure filters. If
@@ -373,7 +368,7 @@ func IncidentToAdjacentStrategy() TraversalStrategy {
 // a graph provider may need to reason about when writing their own strategies. As a result, this strategy helps
 // increase the likelihood that a provider's filtering optimization will succeed at re-writing the traversal.
 func InlineFilterStrategy() TraversalStrategy {
-	return &traversalStrategy{name: optimizationNamespace + "InlineFilterStrategy"}
+	return &traversalStrategy{name: "InlineFilterStrategy"}
 }
 
 // LazyBarrierStrategy is an OLTP-only strategy that automatically inserts a NoOpBarrierStep after every
@@ -381,25 +376,25 @@ func InlineFilterStrategy() TraversalStrategy {
 // traversal's last step or a barrier. NoOpBarrierSteps allow Traversers to be bulked, thus this strategy
 // is meant to reduce memory requirements and improve the overall query performance.
 func LazyBarrierStrategy() TraversalStrategy {
-	return &traversalStrategy{name: optimizationNamespace + "LazyBarrierStrategy"}
+	return &traversalStrategy{name: "LazyBarrierStrategy"}
 }
 
 // MatchPredicateStrategy will fold any post-Where() step that maintains a traversal constraint into
 // Match(). MatchStep is intelligent with traversal constraint applications and thus, can more
 // efficiently use the constraint of WhereTraversalStep or WherePredicateStep.
 func MatchPredicateStrategy() TraversalStrategy {
-	return &traversalStrategy{name: optimizationNamespace + "MatchPredicateStrategy"}
+	return &traversalStrategy{name: "MatchPredicateStrategy"}
 }
 
-func MessagePassingReductionStrategy() TraversalStrategy {
-	return &traversalStrategy{name: computerOptimizationNamespace + "MessagePassingReductionStrategy"}
+func MessagePassingReductionStrategy(options ...map[string]interface{}) TraversalStrategy {
+	return &traversalStrategy{name: "MessagePassingReductionStrategy", configuration: options[0]}
 }
 
 // OrderLimitStrategy is an OLAP strategy that folds a RangeGlobalStep into a preceding
 // OrderGlobalStep. This helps to eliminate traversers early in the traversal and can
 // significantly reduce the amount of memory required by the OLAP execution engine.
 func OrderLimitStrategy() TraversalStrategy {
-	return &traversalStrategy{name: optimizationNamespace + "OrderLimitStrategy"}
+	return &traversalStrategy{name: "OrderLimitStrategy"}
 }
 
 // PathProcessorStrategy  is an OLAP strategy that does its best to turn non-local children in Where()
@@ -407,13 +402,13 @@ func OrderLimitStrategy() TraversalStrategy {
 // PathProcessorStrategy helps to ensure that more traversals meet the local child constraint imposed
 // on OLAP traversals.
 func PathProcessorStrategy() TraversalStrategy {
-	return &traversalStrategy{name: optimizationNamespace + "PathProcessorStrategy"}
+	return &traversalStrategy{name: "PathProcessorStrategy"}
 }
 
 // PathRetractionStrategy will remove Paths from the Traversers and increase the likelihood of bulking
 // as Path data is not required after Select('b').
 func PathRetractionStrategy() TraversalStrategy {
-	return &traversalStrategy{name: optimizationNamespace + "PathRetractionStrategy"}
+	return &traversalStrategy{name: "PathRetractionStrategy"}
 }
 
 // ProductiveByStrategy takes an argument of By() and wraps it CoalesceStep so that the result is either
@@ -426,7 +421,7 @@ func ProductiveByStrategy(config ...ProductiveByStrategyConfig) TraversalStrateg
 		configMap["productiveKeys"] = config[0].ProductiveKeys
 	}
 
-	return &traversalStrategy{name: optimizationNamespace + "ProductiveByStrategy", configuration: configMap}
+	return &traversalStrategy{name: "ProductiveByStrategy", configuration: configMap}
 }
 
 // ProductiveByStrategyConfig provides configuration options for ProductiveByStrategy.
@@ -443,7 +438,7 @@ type ProductiveByStrategyConfig struct {
 //	LoopsStep
 //	LambdaHolder
 func RepeatUnrollStrategy() TraversalStrategy {
-	return &traversalStrategy{name: optimizationNamespace + "RepeatUnrollStrategy"}
+	return &traversalStrategy{name: "RepeatUnrollStrategy"}
 }
 
 // RemoteStrategy reconstructs a Traversal by appending a RemoteStep to its end. That step will submit the Traversal to
@@ -455,7 +450,7 @@ func RemoteStrategy(connection DriverRemoteConnection) TraversalStrategy {
 			return
 		}
 
-		rs, err := connection.submitBytecode(g.Bytecode)
+		rs, err := connection.submitGremlinLang(g.GremlinLang)
 		if err != nil {
 			return
 		}
diff --git a/gremlin-go/driver/strategies_test.go b/gremlin-go/driver/strategies_test.go
index c519be5d66..d5f95eb77d 100644
--- a/gremlin-go/driver/strategies_test.go
+++ b/gremlin-go/driver/strategies_test.go
@@ -21,6 +21,7 @@ package gremlingo
 
 import (
 	"crypto/tls"
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -120,19 +121,12 @@ func TestStrategy(t *testing.T) {
 		assert.Equal(t, int32(0), val)
 	})
 
-	t.Run("Test Bytecode generation for MatchAlgorithmStrategy", func(t *testing.T) {
-		g := getModernGraph(t, testNoAuthUrl, &AuthInfo{}, &tls.Config{})
-		defer g.remoteConnection.Close()
+	t.Run("Test GremlinLang generation for MatchAlgorithmStrategy", func(t *testing.T) {
+		g := NewGraphTraversalSource(nil, nil)
 
 		config := MatchAlgorithmStrategyConfig{MatchAlgorithm: "greedy"}
-		bytecode := g.WithStrategies(MatchAlgorithmStrategy(config)).bytecode
-		assert.Equal(t, 1, len(bytecode.sourceInstructions))
-		assert.Equal(t, 1, len(bytecode.sourceInstructions[0].arguments))
-		assert.Equal(t, "withStrategies", bytecode.sourceInstructions[0].operator)
-		assert.Equal(t, "org.apache.tinkerpop.gremlin.process.traversal.strategy.finalization.MatchAlgorithmStrategy",
-			bytecode.sourceInstructions[0].arguments[0].(*traversalStrategy).name)
-		assert.Equal(t, map[string]interface{}{"matchAlgorithm": "greedy"},
-			bytecode.sourceInstructions[0].arguments[0].(*traversalStrategy).configuration)
+		gl := g.WithStrategies(MatchAlgorithmStrategy(config)).gremlinLang
+		assert.True(t, strings.Contains(gl.GetGremlin(), "withStrategies(new MatchAlgorithmStrategy(matchAlgorithm:\"greedy\"))"))
 	})
 
 	t.Run("Test read with AdjacentToIncidentStrategy", func(t *testing.T) {
@@ -427,4 +421,22 @@ func TestStrategy(t *testing.T) {
 		assert.Equal(t, int32(6), val)
 	})
 
+
+	t.Run("Test GremlinLang generation for simple custom strategies", func(t *testing.T) {
+		g := NewGraphTraversalSource(nil, nil)
+
+		customStrategy := NewTraversalStrategy("CustomSingletonStrategy", nil)
+		gl := g.WithStrategies(customStrategy).gremlinLang
+		assert.True(t, strings.Contains(gl.GetGremlin(), "withStrategies(CustomSingletonStrategy)"))
+	})
+
+	t.Run("Test GremlinLang generation for config custom strategies", func(t *testing.T) {
+		g := NewGraphTraversalSource(nil, nil)
+
+		customStrategy := NewTraversalStrategy("CustomConfigurableStrategy",
+			map[string]interface{}{"stringKey": "string value", "intKey": 5, "booleanKey": true})
+		gl := g.WithStrategies(customStrategy).gremlinLang
+		assert.True(t, strings.Contains(gl.GetGremlin(),
+			"withStrategies(new CustomConfigurableStrategy(stringKey:\"string value\",intKey:5,booleanKey:true))"))
+	})
 }
diff --git a/gremlin-go/driver/traversal.go b/gremlin-go/driver/traversal.go
index d23a8b18c2..a1948e6aa6 100644
--- a/gremlin-go/driver/traversal.go
+++ b/gremlin-go/driver/traversal.go
@@ -32,10 +32,11 @@ type Traverser struct {
 
 // Traversal is the primary way in which graphs are processed.
 type Traversal struct {
-	graph    *Graph
-	Bytecode *Bytecode
-	remote   *DriverRemoteConnection
-	results  ResultSet
+	graph       *Graph
+	Bytecode    *Bytecode
+	GremlinLang *GremlinLang
+	remote      *DriverRemoteConnection
+	results     ResultSet
 }
 
 // ToList returns the result in a list.
@@ -44,7 +45,8 @@ func (t *Traversal) ToList() ([]*Result, error) {
 		return nil, newError(err0901ToListAnonTraversalError)
 	}
 
-	results, err := t.remote.submitBytecode(t.Bytecode)
+	// TODO update and test when connection is set up
+	results, err := t.remote.submitGremlinLang(t.GremlinLang)
 	if err != nil {
 		return nil, err
 	}
@@ -77,12 +79,10 @@ func (t *Traversal) Iterate() <-chan error {
 			return
 		}
 
-		if err := t.Bytecode.AddStep("discard"); err != nil {
-			r <- err
-			return
-		}
+		t.GremlinLang.AddStep("discard")
 
-		res, err := t.remote.submitBytecode(t.Bytecode)
+		// TODO update and test when connection is set up
+		res, err := t.remote.submitGremlinLang(t.GremlinLang)
 		if err != nil {
 			r <- err
 			return
@@ -125,7 +125,8 @@ func (t *Traversal) Next() (*Result, error) {
 // GetResultSet submits the traversal and returns the ResultSet.
 func (t *Traversal) GetResultSet() (ResultSet, error) {
 	if t.results == nil {
-		results, err := t.remote.submitBytecode(t.Bytecode)
+		// TODO update and test when connection is set up
+		results, err := t.remote.submitGremlinLang(t.GremlinLang)
 		if err != nil {
 			return nil, err
 		}
@@ -749,31 +750,32 @@ var IO = ioconfig{
 	Registry: "~tinkerpop.ioconfig.registry",
 }
 
+// TODO pending update/removal
 // Metrics holds metrics data; typically for .profile()-step analysis. Metrics may be nested. Nesting enables
 // the ability to capture explicit metrics for multiple distinct operations. Annotations are used to store
 // miscellaneous notes that might be useful to a developer when examining results, such as index coverage
 // for Steps in a Traversal.
-type Metrics struct {
-	Id   string
-	Name string
-	// the duration in nanoseconds.
-	Duration      int64
-	Counts        map[string]int64
-	Annotations   map[string]interface{}
-	NestedMetrics []Metrics
-}
+//type Metrics struct {
+//	Id   string
+//	Name string
+//	// the duration in nanoseconds.
+//	Duration      int64
+//	Counts        map[string]int64
+//	Annotations   map[string]interface{}
+//	NestedMetrics []Metrics
+//}
 
 // TraversalMetrics contains the Metrics gathered for a Traversal as the result of the .profile()-step.
-type TraversalMetrics struct {
-	// the duration in nanoseconds.
-	Duration int64
-	Metrics  []Metrics
-}
+//type TraversalMetrics struct {
+//	// the duration in nanoseconds.
+//	Duration int64
+//	Metrics  []Metrics
+//}
 
 // GremlinType represents the GraphBinary type Class which can be used to serialize a class.
-type GremlinType struct {
-	Fqcn string
-}
+//type GremlinType struct {
+//	Fqcn string
+//}
 
 // BigDecimal represents an arbitrary-precision signed decimal number, consisting of an arbitrary precision integer
 // unscaled value and a 32-bit integer scale.
diff --git a/gremlin-go/driver/traversal_test.go b/gremlin-go/driver/traversal_test.go
index c8d130d7b7..97520bf76c 100644
--- a/gremlin-go/driver/traversal_test.go
+++ b/gremlin-go/driver/traversal_test.go
@@ -31,7 +31,7 @@ import (
 func TestTraversal(t *testing.T) {
 
 	t.Run("Test clone traversal", func(t *testing.T) {
-		g := cloneGraphTraversalSource(&Graph{}, NewBytecode(nil), nil)
+		g := cloneGraphTraversalSource(&Graph{}, NewGremlinLang(nil), nil)
 		original := g.V().Out("created")
 		clone := original.Clone().Out("knows")
 		cloneClone := clone.Clone().Out("created")
@@ -56,7 +56,7 @@ func TestTraversal(t *testing.T) {
 	})
 
 	t.Run("Test traversal with bindings", func(t *testing.T) {
-		g := cloneGraphTraversalSource(&Graph{}, NewBytecode(nil), nil)
+		g := cloneGraphTraversalSource(&Graph{}, NewGremlinLang(nil), nil)
 		bytecode := g.V((&Bindings{}).Of("a", []int32{1, 2, 3})).
 			Out((&Bindings{}).Of("b", "created")).
 			Where(T__.In((&Bindings{}).Of("c", "created"), (&Bindings{}).Of("d", "knows")).
diff --git a/gremlin-go/pom.xml b/gremlin-go/pom.xml
index bbd953205a..41973b9dff 100644
--- a/gremlin-go/pom.xml
+++ b/gremlin-go/pom.xml
@@ -86,10 +86,9 @@ limitations under the License.
             <id>glv-go</id>
             <activation>
                 <activeByDefault>false</activeByDefault>
-                <!-- TODO re-enable after gremlin-go is implemented -->
-<!--                <file>-->
-<!--                    <exists>.glv</exists>-->
-<!--                </file>-->
+                <file>
+                    <exists>.glv</exists>
+                </file>
             </activation>
             <build>
                 <directory>${basedir}/target</directory>
@@ -124,40 +123,40 @@ limitations under the License.
                                     </arguments>
                                 </configuration>
                             </execution>
-                            <execution>
-                                <id>shutdown-container</id>
-                                <phase>integration-test</phase>
-                                <goals>
-                                    <goal>exec</goal>
-                                </goals>
-                                <configuration>
-                                    <skip>${skipTests}</skip>
-                                    <!-- don't need to set env variables for container tear down -->
-                                    <executable>docker</executable>
-                                    <arguments>
-                                        <argument>compose</argument>
-                                        <argument>down</argument>
-                                    </arguments>
-                                </configuration>
-                            </execution>
-                            <execution>
-                                <id>remove-dangling-images</id>
-                                <phase>integration-test</phase>
-                                <goals>
-                                    <goal>exec</goal>
-                                </goals>
-                                <configuration>
-                                    <skip>${skipTests}</skip>
-                                    <executable>docker</executable>
-                                    <arguments>
-                                        <argument>image</argument>
-                                        <argument>prune</argument>
-                                        <argument>--filter</argument>
-                                        <argument>label=maintainer=dev@tinkerpop.apache.org</argument>
-                                        <argument>-f</argument>
-                                    </arguments>
-                                </configuration>
-                            </execution>
+<!--                            <execution>-->
+<!--                                <id>shutdown-container</id>-->
+<!--                                <phase>integration-test</phase>-->
+<!--                                <goals>-->
+<!--                                    <goal>exec</goal>-->
+<!--                                </goals>-->
+<!--                                <configuration>-->
+<!--                                    <skip>${skipTests}</skip>-->
+<!--                                    &lt;!&ndash; don't need to set env variables for container tear down &ndash;&gt;-->
+<!--                                    <executable>docker</executable>-->
+<!--                                    <arguments>-->
+<!--                                        <argument>compose</argument>-->
+<!--                                        <argument>down</argument>-->
+<!--                                    </arguments>-->
+<!--                                </configuration>-->
+<!--                            </execution>-->
+<!--                            <execution>-->
+<!--                                <id>remove-dangling-images</id>-->
+<!--                                <phase>integration-test</phase>-->
+<!--                                <goals>-->
+<!--                                    <goal>exec</goal>-->
+<!--                                </goals>-->
+<!--                                <configuration>-->
+<!--                                    <skip>${skipTests}</skip>-->
+<!--                                    <executable>docker</executable>-->
+<!--                                    <arguments>-->
+<!--                                        <argument>image</argument>-->
+<!--                                        <argument>prune</argument>-->
+<!--                                        <argument>&#45;&#45;filter</argument>-->
+<!--                                        <argument>label=maintainer=dev@tinkerpop.apache.org</argument>-->
+<!--                                        <argument>-f</argument>-->
+<!--                                    </arguments>-->
+<!--                                </configuration>-->
+<!--                            </execution>-->
                         </executions>
                     </plugin>
                     <plugin>


(tinkerpop) 02/02: fix various gremlinlang and serializer bugs in go for http

Posted by xi...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

xiazcy pushed a commit to branch go-http-converge-conn-lang
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git

commit 4393a5a3b8a488c9131b0c86b4a1d73159161c48
Author: Yang Xia <xi...@gmail.com>
AuthorDate: Mon Dec 22 13:44:32 2025 -0800

    fix various gremlinlang and serializer bugs in go for http
---
 .../language/translator/GremlinTranslatorTest.java |  12 +-
 gremlin-go/driver/client.go                        |  47 +-
 gremlin-go/driver/client_test.go                   |  14 +-
 gremlin-go/driver/connection_test.go               | 161 +----
 gremlin-go/driver/cucumber/cucumberSteps_test.go   |   3 -
 gremlin-go/driver/cucumber/cucumberWorld.go        |  62 +-
 gremlin-go/driver/driverRemoteConnection.go        |  37 +-
 gremlin-go/driver/error_codes.go                   |   1 +
 gremlin-go/driver/graphBinary.go                   |  14 +-
 gremlin-go/driver/graphBinary_test.go              |  23 +-
 gremlin-go/driver/graphTraversal.go                |   8 +-
 gremlin-go/driver/graphTraversalSource.go          |   6 +-
 gremlin-go/driver/gremlinClient.go                 | 148 -----
 gremlin-go/driver/gremlinlang.go                   | 178 +++--
 gremlin-go/driver/gremlinlang_test.go              |  45 +-
 gremlin-go/driver/httpTransporter.go               |   7 +-
 gremlin-go/driver/logger.go                        |   1 -
 gremlin-go/driver/serializer.go                    |  13 +-
 gremlin-go/driver/strategies.go                    |  40 +-
 gremlin-go/driver/translator.go                    | 365 -----------
 gremlin-go/driver/translator_test.go               | 717 ---------------------
 gremlin-go/driver/traversal.go                     |  52 +-
 gremlin-go/driver/traversal_test.go                |  14 +-
 gremlin-go/examples/go.mod                         |   4 +-
 gremlin-go/examples/go.sum                         |   2 +
 gremlin-go/go.mod                                  |  16 +-
 gremlin-go/go.sum                                  |  33 +-
 .../python/gremlin_python/process/traversal.py     |   2 +-
 28 files changed, 410 insertions(+), 1615 deletions(-)

diff --git a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/translator/GremlinTranslatorTest.java b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/translator/GremlinTranslatorTest.java
index d89dba51b4..f08355d1a2 100644
--- a/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/translator/GremlinTranslatorTest.java
+++ b/gremlin-core/src/test/java/org/apache/tinkerpop/gremlin/language/translator/GremlinTranslatorTest.java
@@ -699,23 +699,13 @@ public class GremlinTranslatorTest {
                     {"g.withStrategies(ReservedKeysVerificationStrategy(throwException: true, keys: [\"age\"])).addV(\"person\").property(\"age\", 29).property(\"name\", \"marko\")",
                             "g.withStrategies(ReservedKeysVerificationStrategy(throwException:true, keys:[\"age\"])).addV(\"person\").property(\"age\", 29).property(\"name\", \"marko\")",
                             "g.withStrategies(ReservedKeysVerificationStrategy(throwException:boolean0, keys:list0)).addV(string0).property(string1, number0).property(string2, string3)",
-                            "g.WithStrategies(new ReservedKeysVerificationStrategy(throwException: true, keys: new List<object> { \"age\" })).AddV(\"person\").Property(\"age\", 29).Property(\"name\", \"marko\")",
+                            "g.WithStrategies(new ReservedKeysVerificationStrategy(throwException: true, keys: new List<object> { \"age\" })).AddV((string) \"person\").Property(\"age\", 29).Property(\"name\", \"marko\")",
                             "g.WithStrategies(gremlingo.ReservedKeysVerificationStrategy(gremlingo.ReservedKeysVerificationStrategyConfig{ThrowException: true, Keys: []string{\"age\"}})).AddV(\"person\").Property(\"age\", 29).Property(\"name\", \"marko\")",
                             "g.withStrategies(new ReservedKeysVerificationStrategy(throwException:true, keys:[\"age\"])).addV(\"person\").property(\"age\", 29).property(\"name\", \"marko\")",
                             "g.withStrategies(ReservedKeysVerificationStrategy.build().throwException(true).keys(new ArrayList<Object>() {{ add(\"age\"); }}).create()).addV(\"person\").property(\"age\", 29).property(\"name\", \"marko\")",
                             "g.withStrategies(new ReservedKeysVerificationStrategy({throwException: true, keys: [\"age\"]})).addV(\"person\").property(\"age\", 29).property(\"name\", \"marko\")",
                             "g.with_strategies(ReservedKeysVerificationStrategy(throw_exception=True, keys=['age'])).add_v('person').property('age', 29).property('name', 'marko')"
                     },
-                    {"g.withStrategies(OptionsStrategy(myVar: \"myValue\")).V()",
-                            "g.withStrategies(OptionsStrategy(myVar:\"myValue\")).V()",
-                            "g.withStrategies(OptionsStrategy(myVar:string0)).V()",
-                            "g.WithStrategies(new OptionsStrategy(myVar: \"myValue\")).V()",
-                            "g.WithStrategies(gremlingo.OptionsStrategy(map[string]interface{}{\"myVar\": \"myValue\"})).V()",
-                            "g.withStrategies(new OptionsStrategy(myVar:\"myValue\")).V()",
-                            "g.withStrategies(OptionsStrategy.build().myVar(\"myValue\").create()).V()",
-                            "g.withStrategies(new OptionsStrategy({myVar: \"myValue\"})).V()",
-                            "g.with_strategies(OptionsStrategy(my_var='myValue')).V()"
-                    },
                     {"g.withoutStrategies(ReadOnlyStrategy, PathRetractionStrategy, FilterRankingStrategy)",
                             null,
                             null,
diff --git a/gremlin-go/driver/client.go b/gremlin-go/driver/client.go
index 12b6c4e9c6..7ce9a8839a 100644
--- a/gremlin-go/driver/client.go
+++ b/gremlin-go/driver/client.go
@@ -21,6 +21,7 @@ package gremlingo
 
 import (
 	"crypto/tls"
+	"reflect"
 	"runtime"
 	"time"
 
@@ -134,7 +135,7 @@ func (client *Client) SubmitWithOptions(traversalString string, requestOptions R
 	request := makeStringRequest(traversalString, client.traversalSource, requestOptions)
 
 	// TODO interceptors (ie. auth)
-	
+
 	rs, err := client.httpProtocol.send(&request)
 	return rs, err
 }
@@ -156,13 +157,47 @@ func (client *Client) submitGremlinLang(gremlinLang *GremlinLang) (ResultSet, er
 	client.logHandler.logf(Debug, submitStartedString, *gremlinLang)
 	// TODO placeholder
 	requestOptionsBuilder := new(RequestOptionsBuilder)
+	if len(gremlinLang.GetParameters()) > 0 {
+		requestOptionsBuilder.SetBindings(gremlinLang.GetParameters())
+	}
+	if len(gremlinLang.optionsStrategies) > 0 {
+		requestOptionsBuilder = applyOptionsConfig(requestOptionsBuilder, gremlinLang.optionsStrategies[0].configuration)
+	}
+
 	request := makeStringRequest(gremlinLang.GetGremlin(), client.traversalSource, requestOptionsBuilder.Create())
 	return client.httpProtocol.send(&request)
 }
 
-// submitBytecode submits Bytecode to the server to execute and returns a ResultSet.
-func (client *Client) submitBytecode(bytecode *Bytecode) (ResultSet, error) {
-	client.logHandler.logf(Debug, submitStartedBytecode, *bytecode)
-	request := makeBytecodeRequest(bytecode, client.traversalSource)
-	return client.httpProtocol.send(&request)
+func applyOptionsConfig(builder *RequestOptionsBuilder, config map[string]interface{}) *RequestOptionsBuilder {
+	builderValue := reflect.ValueOf(builder)
+
+	// Map configuration keys to setter method names
+	setterMap := map[string]string{
+		"requestId":             "SetRequestId",
+		"evaluationTimeout":     "SetEvaluationTimeout",
+		"batchSize":             "SetBatchSize",
+		"userAgent":             "SetUserAgent",
+		"bindings":              "SetBindings",
+		"materializeProperties": "SetMaterializeProperties",
+	}
+
+	for key, value := range config {
+		if methodName, exists := setterMap[key]; exists {
+			method := builderValue.MethodByName(methodName)
+			if method.IsValid() {
+				args := []reflect.Value{reflect.ValueOf(value)}
+				method.Call(args)
+			}
+		}
+	}
+
+	return builder
 }
+
+// submitBytecode submits Bytecode to the server to execute and returns a ResultSet.
+// TODO remove
+//func (client *Client) submitBytecode(bytecode *Bytecode) (ResultSet, error) {
+//	client.logHandler.logf(Debug, submitStartedBytecode, *bytecode)
+//	request := makeBytecodeRequest(bytecode, client.traversalSource)
+//	return client.httpProtocol.send(&request)
+//}
diff --git a/gremlin-go/driver/client_test.go b/gremlin-go/driver/client_test.go
index 6068f89ecc..9e223dd193 100644
--- a/gremlin-go/driver/client_test.go
+++ b/gremlin-go/driver/client_test.go
@@ -62,7 +62,7 @@ func TestClient(t *testing.T) {
 			})
 		assert.NoError(t, err)
 		assert.NotNil(t, client)
-		resultSet, err := client.Submit("2+2")
+		resultSet, err := client.Submit("g.inject(2)")
 		assert.NoError(t, err)
 		assert.NotNil(t, resultSet)
 
@@ -104,9 +104,9 @@ func TestClient(t *testing.T) {
 		assert.NotNil(t, client)
 		defer client.Close()
 
-		bindings := map[string]interface{}{"x": 2}
+		bindings := map[string]interface{}{"x": 1}
 
-		resultSet, err := client.Submit("x + x", bindings)
+		resultSet, err := client.Submit("g.V(x).values(\"name\")", bindings)
 		assert.NoError(t, err)
 		assert.NotNil(t, resultSet)
 
@@ -114,7 +114,7 @@ func TestClient(t *testing.T) {
 		assert.NoError(t, err)
 		assert.True(t, ok)
 
-		assert.Equal(t, int64(4), result.Data)
+		assert.Equal(t, "marko", result.Data)
 	})
 
 	t.Run("Test client.SubmitWithOptions() with bindings", func(t *testing.T) {
@@ -129,9 +129,9 @@ func TestClient(t *testing.T) {
 		assert.NotNil(t, client)
 		defer client.Close()
 
-		bindings := map[string]interface{}{"x": 2}
+		bindings := map[string]interface{}{"x": 1}
 
-		resultSet, err := client.SubmitWithOptions("x + x", new(RequestOptionsBuilder).SetBindings(bindings).Create())
+		resultSet, err := client.SubmitWithOptions("g.V(x).values(\"name\")", new(RequestOptionsBuilder).SetBindings(bindings).Create())
 		assert.NoError(t, err)
 		assert.NotNil(t, resultSet)
 
@@ -139,7 +139,7 @@ func TestClient(t *testing.T) {
 		assert.NoError(t, err)
 		assert.True(t, ok)
 
-		assert.Equal(t, int64(4), result.Data)
+		assert.Equal(t, "marko", result.Data)
 	})
 
 	t.Run("Test client.submit() with materializeProperties", func(t *testing.T) {
diff --git a/gremlin-go/driver/connection_test.go b/gremlin-go/driver/connection_test.go
index d24c6158ff..be13a9a8e5 100644
--- a/gremlin-go/driver/connection_test.go
+++ b/gremlin-go/driver/connection_test.go
@@ -22,7 +22,6 @@ package gremlingo
 import (
 	"crypto/tls"
 	"fmt"
-	"github.com/stretchr/testify/assert"
 	"math/big"
 	"os"
 	"reflect"
@@ -30,6 +29,8 @@ import (
 	"strconv"
 	"sync"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
 const personLabel = "Person"
@@ -663,142 +664,28 @@ func TestConnection(t *testing.T) {
 		}
 	})
 
-	t.Run("Test Client.Submit() Simple String Query with Bindings", func(t *testing.T) {
-		skipTestsIfNotEnabled(t, integrationTestSuiteName, testNoAuthEnable)
-
-		client, err := NewClient(testNoAuthUrl,
-			func(settings *ClientSettings) {
-				settings.TlsConfig = testNoAuthTlsConfig
-				settings.AuthInfo = testNoAuthAuthInfo
-			})
-		assert.Nil(t, err)
-		assert.NotNil(t, client)
-		defer client.Close()
-
-		resultSet, err := client.Submit("g.inject(x).math('_+_')", map[string]interface{}{"x": 2})
-		assert.Nil(t, err)
-		assert.NotNil(t, resultSet)
-		result, ok, err := resultSet.One()
-		assert.Nil(t, err)
-		assert.True(t, ok)
-		assert.NotNil(t, result)
-		res, err := result.GetInt()
-		assert.Nil(t, err)
-		assert.Equal(t, 4, res)
-	})
-
-	t.Run("Test Bindings To Server Configured with Modern Graph", func(t *testing.T) {
-		skipTestsIfNotEnabled(t, integrationTestSuiteName, testNoAuthWithAliasEnable)
-		remote, err := NewDriverRemoteConnection(testNoAuthWithAliasUrl,
-			func(settings *DriverRemoteConnectionSettings) {
-				settings.TlsConfig = testNoAuthWithAliasTlsConfig
-				settings.AuthInfo = testNoAuthWithAliasAuthInfo
-				settings.TraversalSource = testServerModernGraphAlias
-			})
-		assert.Nil(t, err)
-		assert.NotNil(t, remote)
-		defer remote.Close()
-		g := Traversal_().With(remote)
-
-		r, err := g.V((&Bindings{}).Of("x", 1)).Out("created").Map(&Lambda{Script: "it.get().value('name').length()", Language: ""}).Sum().ToList()
-		assert.Nil(t, err)
-		for _, res := range r {
-			assert.Equal(t, int32(3), res.GetInterface())
-		}
-		r, err = g.V((&Bindings{}).Of("x", 4)).Out("created").Map(&Lambda{Script: "it.get().value('name').length()", Language: ""}).Sum().ToList()
-		assert.Nil(t, err)
-		for _, res := range r {
-			assert.Equal(t, int32(9), res.GetInterface())
-		}
-	})
-
-	t.Run("Test DriverRemoteConnection Invalid GraphTraversal", func(t *testing.T) {
-		skipTestsIfNotEnabled(t, integrationTestSuiteName, testNoAuthEnable)
-
-		// Initialize graph
-		g := initializeGraph(t, testNoAuthUrl, testNoAuthAuthInfo, testNoAuthTlsConfig)
-
-		// Drop the graph.
-		dropGraph(t, g)
-
-		// Add vertices and edges to graph.
-		rs, err := g.AddV("person").Property("id", T__.Unfold().Property().AddV()).ToList()
-		assert.Nil(t, rs)
-		assert.True(t, isSameErrorCode(newError(err0502ResponseHandlerError), err))
-
-		rs, err = g.V().Count().ToList()
-		assert.NotNil(t, rs)
-		assert.Nil(t, err)
-
-		// Drop the graph.
-		dropGraph(t, g)
-	})
-
-	t.Run("Test per-request arguments", func(t *testing.T) {
-		skipTestsIfNotEnabled(t, integrationTestSuiteName, testNoAuthEnable)
-
-		g := getTestGraph(t, testNoAuthUrl, testNoAuthAuthInfo, testNoAuthTlsConfig)
-		defer g.remoteConnection.Close()
-
-		reqArgsTests := []struct {
-			msg       string
-			traversal *GraphTraversal
-			nilErr    bool
-		}{
-			{
-				"Traversal must time out (With)",
-				g.
-					With("evaluationTimeout", 10).
-					Inject(1).
-					SideEffect(&Lambda{"Thread.sleep(5000)", "gremlin-groovy"}),
-				false,
-			},
-			{
-				"Traversal must finish (With)",
-				g.
-					With("evaluationTimeout", 10000).
-					Inject(1).
-					SideEffect(&Lambda{"Thread.sleep(5000)", "gremlin-groovy"}),
-				true,
-			},
-			{
-				"evaluationTimeout is overridden and traversal must time out (With)",
-				g.
-					With("evaluationTimeout", 10000).With("evaluationTimeout", 10).
-					Inject(1).
-					SideEffect(&Lambda{"Thread.sleep(5000)", "gremlin-groovy"}),
-				false,
-			},
-			{
-				"Traversal must time out (OptionsStrategy)",
-				g.
-					WithStrategies(OptionsStrategy(map[string]interface{}{"evaluationTimeout": 10})).
-					Inject(1).
-					SideEffect(&Lambda{"Thread.sleep(5000)", "gremlin-groovy"}),
-				false,
-			},
-			{
-				"Traversal must finish (OptionsStrategy)",
-				g.
-					WithStrategies(OptionsStrategy(map[string]interface{}{"evaluationTimeout": 10000})).
-					Inject(1).
-					SideEffect(&Lambda{"Thread.sleep(5000)", "gremlin-groovy"}),
-				true,
-			},
-		}
-
-		gotErrs := make([]<-chan error, len(reqArgsTests))
-
-		// Run tests in parallel.
-		for i, tt := range reqArgsTests {
-			gotErrs[i] = tt.traversal.Iterate()
-		}
-
-		// Check error promises.
-		for i, tt := range reqArgsTests {
-			assert.Equal(t, <-gotErrs[i] == nil, tt.nilErr, tt.msg)
-		}
-	})
+	// TODO enable after error response is deser properly
+	//t.Run("Test DriverRemoteConnection Invalid GraphTraversal", func(t *testing.T) {
+	//	skipTestsIfNotEnabled(t, integrationTestSuiteName, testNoAuthEnable)
+	//
+	//	// Initialize graph
+	//	g := initializeGraph(t, testNoAuthUrl, testNoAuthAuthInfo, testNoAuthTlsConfig)
+	//
+	//	// Drop the graph.
+	//	dropGraph(t, g)
+	//
+	//	// Add vertices and edges to graph.
+	//	rs, err := g.AddV("person").Property("id", T__.Unfold().Property().AddV()).ToList()
+	//	assert.Nil(t, rs)
+	//	assert.True(t, isSameErrorCode(newError(err0502ResponseHandlerError), err))
+	//
+	//	rs, err = g.V().Count().ToList()
+	//	assert.NotNil(t, rs)
+	//	assert.Nil(t, err)
+	//
+	//	// Drop the graph.
+	//	dropGraph(t, g)
+	//})
 
 	t.Run("Get all properties when materializeProperties is all", func(t *testing.T) {
 		skipTestsIfNotEnabled(t, integrationTestSuiteName, testNoAuthEnable)
diff --git a/gremlin-go/driver/cucumber/cucumberSteps_test.go b/gremlin-go/driver/cucumber/cucumberSteps_test.go
index 0942ae1384..f9caa7e187 100644
--- a/gremlin-go/driver/cucumber/cucumberSteps_test.go
+++ b/gremlin-go/driver/cucumber/cucumberSteps_test.go
@@ -951,11 +951,8 @@ func InitializeScenario(ctx *godog.ScenarioContext) {
 	ctx.Step(`^the result should have a count of (\d+)$`, tg.theResultShouldHaveACountOf)
 	ctx.Step(`^the traversal of$`, tg.theTraversalOf)
 	ctx.Step(`^using the parameter (.+) defined as "(.+)"$`, tg.usingTheParameterDefined)
-<<<<<<< HEAD
-=======
 	ctx.Step(`^using the parameter (.+) of P\.(.+)\("(.+)"\)$`, tg.usingTheParameterOfP)
 	ctx.Step(`^using the side effect (.+) defined as"(.+)"$`, tg.usingTheSideEffectDefined)
->>>>>>> 3.8-dev
 	ctx.Step(`^the traversal will raise an error$`, tg.theTraversalWillRaiseAnError)
 	ctx.Step(`^the traversal will raise an error with message (\w+) text of "(.+)"$`, tg.theTraversalWillRaiseAnErrorWithMessageContainingTextOf)
 }
diff --git a/gremlin-go/driver/cucumber/cucumberWorld.go b/gremlin-go/driver/cucumber/cucumberWorld.go
index 6e6d008af0..ac92ea1db8 100644
--- a/gremlin-go/driver/cucumber/cucumberWorld.go
+++ b/gremlin-go/driver/cucumber/cucumberWorld.go
@@ -21,11 +21,12 @@ package gremlingo
 
 import (
 	"fmt"
-	gremlingo "github.com/apache/tinkerpop/gremlin-go/v3/driver"
-	"github.com/cucumber/godog"
 	"os"
 	"reflect"
 	"strconv"
+
+	gremlingo "github.com/apache/tinkerpop/gremlin-go/v3/driver"
+	"github.com/cucumber/godog"
 )
 
 type CucumberWorld struct {
@@ -164,8 +165,11 @@ func getVertices(g *gremlingo.GraphTraversalSource) map[string]*gremlingo.Vertex
 
 func getEdges(g *gremlingo.GraphTraversalSource) map[string]*gremlingo.Edge {
 	edgeMap := make(map[string]*gremlingo.Edge)
-	resE, err := g.E().Group().By(gremlingo.T__.Project("o", "l", "i").
-		By(gremlingo.T__.OutV().Values("name")).By(gremlingo.T__.Label()).By(gremlingo.T__.InV().Values("name"))).
+	resE, err := g.E().Group().
+		By(gremlingo.T__.Project("o", "l", "i").
+			By(gremlingo.T__.OutV().Values("name")).
+			By(gremlingo.T__.Label()).
+			By(gremlingo.T__.InV().Values("name"))).
 		By(gremlingo.T__.Tail()).Next()
 	if err != nil {
 		return nil
@@ -190,38 +194,44 @@ func getEdgeKey(edgeKeyMap map[interface{}]interface{}) string {
 }
 
 func getVertexProperties(g *gremlingo.GraphTraversalSource) map[string]*gremlingo.VertexProperty {
-	vertexPropertyMap := make(map[string]*gremlingo.VertexProperty)
-	res, err := g.V().Properties().Group().By(&gremlingo.Lambda{
-		Script: "{ it -> \n" +
-			"  def val = it.value()\n" +
-			"  if (val instanceof Integer)\n" +
-			"    val = 'd[' + val + '].i'\n" +
-			"  else if (val instanceof Float)\n" +
-			"    val = 'd[' + val + '].f'\n" +
-			"  else if (val instanceof Double)\n" +
-			"    val = 'd[' + val + '].d'\n" +
-			"  return it.element().value('name') + '-' + it.key() + '->' + val\n" +
-			"}",
-		Language: "",
-	}).By(gremlingo.T__.Tail()).Next()
+	vertexPropsMap := make(map[string]*gremlingo.VertexProperty)
+	res, err := g.V().Properties().Group().
+		By(gremlingo.T__.Project("n", "k", "v").
+			By(gremlingo.T__.Element().Values("name")).
+			By(gremlingo.T__.Key()).
+			By(gremlingo.T__.Value())).
+		By(gremlingo.T__.Tail()).Next()
 	if res == nil {
 		return nil
 	}
 	if err != nil {
 		return nil
 	}
-	v := reflect.ValueOf(res.GetInterface())
-	if v.Kind() != reflect.Map {
-		fmt.Printf("Expecting to get a map as a result, got %v instead.", v.Kind())
+	valMap := reflect.ValueOf(res.GetInterface())
+	if valMap.Kind() != reflect.Map {
+		fmt.Printf("Expecting to get a map as a result, got %v instead.", valMap.Kind())
 		return nil
 	}
-	keys := v.MapKeys()
+	keys := valMap.MapKeys()
 	for _, k := range keys {
-		convKey := k.Convert(v.Type().Key())
-		val := v.MapIndex(convKey)
-		vertexPropertyMap[k.Interface().(string)] = val.Interface().(*gremlingo.VertexProperty)
+		convKey := k.Convert(valMap.Type().Key())
+		val := valMap.MapIndex(convKey)
+		keyMap := reflect.ValueOf(k.Interface()).Elem().Interface().(map[interface{}]interface{})
+		vertexPropsMap[getVPKey(keyMap)] = val.Interface().(*gremlingo.VertexProperty)
+	}
+	return vertexPropsMap
+}
+
+func getVPKey(vpKeyMap map[interface{}]interface{}) string {
+	k := vpKeyMap["k"]
+	v := vpKeyMap["v"]
+	if k == "weight" {
+		v = fmt.Sprint("d[", v, "].d")
+	} else if k == "age" || k == "since" || k == "skill" {
+		v = fmt.Sprint("d[", v, "].i")
 	}
-	return vertexPropertyMap
+	// Format as n-k->v
+	return fmt.Sprint(vpKeyMap["n"], "-", k, "->", v)
 }
 
 // This function is used to isolate connection problems to each scenario, and used in the Before context hook to prevent
diff --git a/gremlin-go/driver/driverRemoteConnection.go b/gremlin-go/driver/driverRemoteConnection.go
index d907a7fc34..a61a9e0ac7 100644
--- a/gremlin-go/driver/driverRemoteConnection.go
+++ b/gremlin-go/driver/driverRemoteConnection.go
@@ -144,22 +144,23 @@ func (driver *DriverRemoteConnection) submitGremlinLang(gremlinLang *GremlinLang
 	return driver.client.submitGremlinLang(gremlinLang)
 }
 
+// TODO remove
 // submitBytecode sends a Bytecode traversal to the server.
-func (driver *DriverRemoteConnection) submitBytecode(bytecode *Bytecode) (ResultSet, error) {
-	if driver.isClosed {
-		return nil, newError(err0203SubmitBytecodeToClosedConnectionError)
-	}
-	return driver.client.submitBytecode(bytecode)
-}
-
-func (driver *DriverRemoteConnection) commit() (ResultSet, error) {
-	bc := &Bytecode{}
-	bc.AddSource("tx", "commit")
-	return driver.submitBytecode(bc)
-}
-
-func (driver *DriverRemoteConnection) rollback() (ResultSet, error) {
-	bc := &Bytecode{}
-	bc.AddSource("tx", "rollback")
-	return driver.submitBytecode(bc)
-}
+//func (driver *DriverRemoteConnection) submitBytecode(bytecode *Bytecode) (ResultSet, error) {
+//	if driver.isClosed {
+//		return nil, newError(err0203SubmitBytecodeToClosedConnectionError)
+//	}
+//	return driver.client.submitBytecode(bytecode)
+//}
+//
+//func (driver *DriverRemoteConnection) commit() (ResultSet, error) {
+//	bc := &Bytecode{}
+//	bc.AddSource("tx", "commit")
+//	return driver.submitBytecode(bc)
+//}
+//
+//func (driver *DriverRemoteConnection) rollback() (ResultSet, error) {
+//	bc := &Bytecode{}
+//	bc.AddSource("tx", "rollback")
+//	return driver.submitBytecode(bc)
+//}
diff --git a/gremlin-go/driver/error_codes.go b/gremlin-go/driver/error_codes.go
index d1fd98af55..03a4b1cf05 100644
--- a/gremlin-go/driver/error_codes.go
+++ b/gremlin-go/driver/error_codes.go
@@ -58,6 +58,7 @@ const (
 
 	// response handling errors
 	err0501ResponseHandlerResultSetNotCreatedError errorCode = "E0501_PROTOCOL_RESPONSEHANDLER_NO_RESULTSET_ON_DATA_RECEIVE"
+	err0502ResponseHandlerReadLoopError            errorCode = "E0502_PROTOCOL_RESPONSEHANDLER_READ_LOOP_ERROR"
 	err0502ResponseHandlerError                    errorCode = "E0502_PROTOCOL_RESPONSEHANDLER_ERROR"
 	err0503ResponseHandlerAuthError                errorCode = "E0503_PROTOCOL_RESPONSEHANDLER_AUTH_ERROR"
 
diff --git a/gremlin-go/driver/graphBinary.go b/gremlin-go/driver/graphBinary.go
index de3c071695..c553b0a2e2 100644
--- a/gremlin-go/driver/graphBinary.go
+++ b/gremlin-go/driver/graphBinary.go
@@ -320,7 +320,7 @@ func edgeWriter(value interface{}, buffer *bytes.Buffer, typeSerializer *graphBi
 	}
 
 	// Not fully qualified.
-	_, err = typeSerializer.writeValue(e.InV.Label, buffer, false)
+	_, err = typeSerializer.writeValue([1]string{e.InV.Label}, buffer, false)
 	if err != nil {
 		return nil, err
 	}
@@ -331,7 +331,7 @@ func edgeWriter(value interface{}, buffer *bytes.Buffer, typeSerializer *graphBi
 	}
 
 	// Not fully qualified.
-	_, err = typeSerializer.writeValue(e.OutV.Label, buffer, false)
+	_, err = typeSerializer.writeValue([1]string{e.OutV.Label}, buffer, false)
 	if err != nil {
 		return nil, err
 	}
@@ -405,7 +405,7 @@ func setWriter(value interface{}, buffer *bytes.Buffer, typeSerializer *graphBin
 	return listWriter(slice, buffer, typeSerializer)
 }
 
-func timeWriter(value interface{}, buffer *bytes.Buffer, _ *graphBinaryTypeSerializer) ([]byte, error) {
+func dateTimeWriter(value interface{}, buffer *bytes.Buffer, _ *graphBinaryTypeSerializer) ([]byte, error) {
 	t := value.(time.Time)
 	err := binary.Write(buffer, binary.BigEndian, int32(t.Year()))
 	if err != nil {
@@ -758,8 +758,8 @@ func readList(data *[]byte, i *int, flag byte) (interface{}, error) {
 			if err != nil {
 				return nil, err
 			}
-			bulk := readIntSafe(data, i)
-			for k := int32(0); k < bulk; k++ {
+			bulk := readLongSafe(data, i)
+			for k := int64(0); k < bulk; k++ {
 				valList = append(valList, val)
 			}
 		}
@@ -850,7 +850,7 @@ func readUuid(data *[]byte, i *int) (interface{}, error) {
 	return id, nil
 }
 
-func timeReader(data *[]byte, i *int) (interface{}, error) {
+func dateTimeReader(data *[]byte, i *int) (interface{}, error) {
 	year := readIntSafe(data, i)
 	month := readByteSafe(data, i)
 	day := readByteSafe(data, i)
@@ -933,7 +933,7 @@ func edgeReader(data *[]byte, i *int) (interface{}, error) {
 	if err != nil {
 		return nil, err
 	}
-	label, err := readUnqualified(data, i, listType, false)
+	label, err := readList(data, i, 0)
 	if err != nil {
 		return nil, err
 	}
diff --git a/gremlin-go/driver/graphBinary_test.go b/gremlin-go/driver/graphBinary_test.go
index f974bef652..eb44538fe1 100644
--- a/gremlin-go/driver/graphBinary_test.go
+++ b/gremlin-go/driver/graphBinary_test.go
@@ -23,15 +23,16 @@ import (
 	"bytes"
 	"encoding/binary"
 	"fmt"
-	"github.com/stretchr/testify/assert"
-	"golang.org/x/text/language"
 	"math/big"
 	"reflect"
 	"testing"
 	"time"
+
+	"github.com/stretchr/testify/assert"
+	"golang.org/x/text/language"
 )
 
-func TestGraphBinaryV1(t *testing.T) {
+func TestGraphBinaryV4(t *testing.T) {
 	t.Run("graphBinaryTypeSerializer tests", func(t *testing.T) {
 		serializer := graphBinaryTypeSerializer{newLogHandler(&defaultLogger{}, Error, language.English)}
 
@@ -296,9 +297,9 @@ func TestGraphBinaryV1(t *testing.T) {
 			pos := 0
 			var buffer bytes.Buffer
 			source := time.Date(2022, 5, 10, 9, 51, 0, 0, time.Local)
-			buf, err := timeWriter(source, &buffer, nil)
+			buf, err := dateTimeWriter(source, &buffer, nil)
 			assert.Nil(t, err)
-			res, err := timeReader(&buf, &pos)
+			res, err := dateTimeReader(&buf, &pos)
 			assert.Nil(t, err)
 			// ISO format
 			assert.Equal(t, source.Format(time.RFC3339Nano), res.(time.Time).Format(time.RFC3339Nano))
@@ -307,9 +308,9 @@ func TestGraphBinaryV1(t *testing.T) {
 			pos := 0
 			var buffer bytes.Buffer
 			source := time.Date(2022, 5, 10, 9, 51, 0, 0, time.Local)
-			buf, err := offsetDateTimeWriter(source, &buffer, nil)
+			buf, err := dateTimeWriter(source, &buffer, nil)
 			assert.Nil(t, err)
-			res, err := offsetDateTimeReader(&buf, &pos)
+			res, err := dateTimeReader(&buf, &pos)
 			assert.Nil(t, err)
 			// ISO format
 			assert.Equal(t, source.Format(time.RFC3339Nano), res.(time.Time).Format(time.RFC3339Nano))
@@ -318,9 +319,9 @@ func TestGraphBinaryV1(t *testing.T) {
 			pos := 0
 			var buffer bytes.Buffer
 			source := time.Date(2022, 5, 10, 9, 51, 0, 0, time.UTC)
-			buf, err := offsetDateTimeWriter(source, &buffer, nil)
+			buf, err := dateTimeWriter(source, &buffer, nil)
 			assert.Nil(t, err)
-			res, err := offsetDateTimeReader(&buf, &pos)
+			res, err := dateTimeReader(&buf, &pos)
 			assert.Nil(t, err)
 			// ISO format
 			assert.Equal(t, source.Format(time.RFC3339Nano), res.(time.Time).Format(time.RFC3339Nano))
@@ -329,9 +330,9 @@ func TestGraphBinaryV1(t *testing.T) {
 			pos := 0
 			var buffer bytes.Buffer
 			source := time.Date(2022, 5, 10, 9, 51, 34, 123456789, GetTimezoneFromOffset(-36000))
-			buf, err := offsetDateTimeWriter(source, &buffer, nil)
+			buf, err := dateTimeWriter(source, &buffer, nil)
 			assert.Nil(t, err)
-			res, err := offsetDateTimeReader(&buf, &pos)
+			res, err := dateTimeReader(&buf, &pos)
 			assert.Nil(t, err)
 			// ISO format
 			assert.Equal(t, source.Format(time.RFC3339Nano), res.(time.Time).Format(time.RFC3339Nano))
diff --git a/gremlin-go/driver/graphTraversal.go b/gremlin-go/driver/graphTraversal.go
index abca84b18f..714e8ee447 100644
--- a/gremlin-go/driver/graphTraversal.go
+++ b/gremlin-go/driver/graphTraversal.go
@@ -116,7 +116,7 @@ func (g *GraphTraversal) As(args ...interface{}) *GraphTraversal {
 
 // AsBool adds the asBool step to the GraphTraversal.
 func (g *GraphTraversal) AsBool(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("asBool", args...)
+	g.GremlinLang.AddStep("asBool", args...)
 	return g
 }
 
@@ -128,7 +128,7 @@ func (g *GraphTraversal) AsDate(args ...interface{}) *GraphTraversal {
 
 // AsNumber adds the asNumber step to the GraphTraversal.
 func (g *GraphTraversal) AsNumber(args ...interface{}) *GraphTraversal {
-	g.Bytecode.AddStep("asNumber", args...)
+	g.GremlinLang.AddStep("asNumber", args...)
 	return g
 }
 
@@ -947,8 +947,8 @@ func (t *Transaction) Begin() (*GraphTraversalSource, error) {
 	}
 
 	gts := &GraphTraversalSource{
-		graph:            t.g.graph,
-		gremlinLang:      t.g.gremlinLang}
+		graph:       t.g.graph,
+		gremlinLang: t.g.gremlinLang}
 	return gts, nil
 }
 
diff --git a/gremlin-go/driver/graphTraversalSource.go b/gremlin-go/driver/graphTraversalSource.go
index 12ae62b0f7..58ad12a9a6 100644
--- a/gremlin-go/driver/graphTraversalSource.go
+++ b/gremlin-go/driver/graphTraversalSource.go
@@ -51,9 +51,9 @@ func NewDefaultGraphTraversalSource() *GraphTraversalSource {
 
 // GetBytecode gets the traversal Bytecode associated with this graph traversal source.
 // TODO remove
-func (gts *GraphTraversalSource) GetBytecode() *Bytecode {
-	return nil
-}
+//func (gts *GraphTraversalSource) GetBytecode() *Bytecode {
+//	return nil
+//}
 
 // GetGraphTraversal gets the graph traversal associated with this graph traversal source.
 func (gts *GraphTraversalSource) GetGraphTraversal() *GraphTraversal {
diff --git a/gremlin-go/driver/gremlinClient.go b/gremlin-go/driver/gremlinClient.go
deleted file mode 100644
index 5a1369c612..0000000000
--- a/gremlin-go/driver/gremlinClient.go
+++ /dev/null
@@ -1,148 +0,0 @@
-/*
-Licensed to the Apache Software Foundation (ASF) under one
-or more contributor license agreements.  See the NOTICE file
-distributed with this work for additional information
-regarding copyright ownership.  The ASF licenses this file
-to you under the Apache License, Version 2.0 (the
-"License"); you may not use this file except in compliance
-with the License.  You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
-*/
-
-package gremlingo
-
-import (
-	"net/http"
-)
-
-// responsible for serializing and sending requests and then receiving and deserializing responses
-type gremlinClient struct {
-	serializer   serializer
-	logHandler   *logHandler
-	url          string
-	connSettings *connectionSettings
-	httpClient   *http.Client
-}
-
-func newGremlinClient(handler *logHandler, url string, connSettings *connectionSettings) *gremlinClient {
-	transport := &http.Transport{
-		TLSClientConfig:    connSettings.tlsConfig,
-		MaxConnsPerHost:    0, // TODO
-		IdleConnTimeout:    0, // TODO
-		DisableCompression: !connSettings.enableCompression,
-	}
-
-	httpClient := http.Client{
-		Transport: transport,
-		Timeout:   connSettings.connectionTimeout,
-	}
-
-	httpProt := &gremlinClient{
-		serializer:   newGraphBinarySerializer(handler),
-		logHandler:   handler,
-		url:          url,
-		connSettings: connSettings,
-		httpClient:   &httpClient,
-	}
-	return httpProt
-}
-
-// sends a query request and returns a ResultSet that can be used to obtain query results
-func (client *gremlinClient) send(request *request) (ResultSet, error) {
-	rs := newChannelResultSet()
-	bytes, err := client.serializer.serializeMessage(request)
-	if err != nil {
-		rs.setError(err)
-		rs.Close()
-		return rs, err
-	}
-
-	// one transport per request
-	transport := newHttpTransporter(client.url, client.connSettings, client.httpClient, client.logHandler)
-
-	// async send request
-	transport.wg.Add(1)
-	go func() {
-		defer transport.wg.Done()
-		err := transport.write(bytes)
-		if err != nil {
-			rs.setError(err)
-			rs.Close()
-		}
-	}()
-
-	// async receive response
-	transport.wg.Add(1)
-	go func() {
-		defer transport.wg.Done()
-		msg, err := transport.read()
-		if err != nil {
-			rs.setError(err)
-			rs.Close()
-		} else {
-			err = client.receive(rs, msg)
-		}
-		transport.close()
-	}()
-
-	return rs, err
-}
-
-// receives a binary response message, deserializes, and adds results to the ResultSet
-func (client *gremlinClient) receive(rs ResultSet, msg []byte) error {
-	resp, err := client.serializer.deserializeMessage(msg)
-	if err != nil {
-		client.logHandler.logf(Error, logErrorGeneric, "deserializeMessage()", err.Error())
-		rs.Close()
-		return err
-	}
-
-	err = client.handleResponse(rs, resp)
-	if err != nil {
-		client.logHandler.logf(Error, logErrorGeneric, "handleResponse()", err.Error())
-		rs.Close()
-		return err
-	}
-	return nil
-}
-
-// processes a deserialized response and attempts to add results to the ResultSet
-func (client *gremlinClient) handleResponse(rs ResultSet, response response) error {
-	statusCode, data := response.responseStatus.code, response.responseResult.data
-	if rs == nil {
-		return newError(err0501ResponseHandlerResultSetNotCreatedError)
-	}
-
-	if statusCode == http.StatusNoContent {
-		rs.addResult(&Result{make([]interface{}, 0)})
-		rs.Close()
-		client.logHandler.logf(Debug, readComplete)
-	} else if statusCode == http.StatusOK {
-		rs.addResult(&Result{data})
-		rs.Close()
-		client.logHandler.logf(Debug, readComplete)
-	} else if statusCode == http.StatusUnauthorized || statusCode == http.StatusForbidden {
-		rs.Close()
-		err := newError(err0503ResponseHandlerAuthError, response.responseStatus, response.responseResult)
-		rs.setError(err)
-		return err
-	} else {
-		rs.Close()
-		err := newError(err0502ResponseHandlerError, response.responseStatus, statusCode)
-		rs.setError(err)
-		return err
-	}
-	return nil
-}
-
-func (client *gremlinClient) close() {
-	client.httpClient.CloseIdleConnections()
-}
diff --git a/gremlin-go/driver/gremlinlang.go b/gremlin-go/driver/gremlinlang.go
index 3a67515030..39165d2bc8 100644
--- a/gremlin-go/driver/gremlinlang.go
+++ b/gremlin-go/driver/gremlinlang.go
@@ -29,6 +29,8 @@ import (
 	"strings"
 	"sync/atomic"
 	"time"
+
+	"github.com/google/uuid"
 )
 
 type GremlinLang struct {
@@ -46,9 +48,17 @@ func NewGremlinLang(gl *GremlinLang) *GremlinLang {
 	optionsStrategies := make([]*traversalStrategy, 0)
 	paramCount := atomic.Uint64{}
 	if gl != nil {
-		gremlin = gl.gremlin
-		parameters = gl.parameters
-		optionsStrategies = gl.optionsStrategies
+		gremlin = make([]string, len(gl.gremlin))
+		copy(gremlin, gl.gremlin)
+
+		parameters = make(map[string]interface{})
+		for k, v := range gl.parameters {
+			parameters[k] = v
+		}
+
+		optionsStrategies = make([]*traversalStrategy, len(gl.optionsStrategies))
+		copy(optionsStrategies, gl.optionsStrategies)
+
 		paramCount.Store(gl.paramCount.Load())
 	}
 
@@ -63,7 +73,6 @@ func NewGremlinLang(gl *GremlinLang) *GremlinLang {
 func (gl *GremlinLang) addToGremlin(name string, args ...interface{}) error {
 	flattenedArgs := gl.flattenArguments(args...)
 	if name == "CardinalityValueTraversal" {
-		gl.gremlin = append(gl.gremlin, "Cardinality.")
 		str0, err := gl.argAsString(flattenedArgs[0])
 		if err != nil {
 			return err
@@ -76,6 +85,7 @@ func (gl *GremlinLang) addToGremlin(name string, args ...interface{}) error {
 		gl.gremlin = append(gl.gremlin, "(")
 		gl.gremlin = append(gl.gremlin, str1)
 		gl.gremlin = append(gl.gremlin, ")")
+		return nil
 	}
 
 	gl.gremlin = append(gl.gremlin, ".")
@@ -112,9 +122,9 @@ func (gl *GremlinLang) argAsString(arg interface{}) (string, error) {
 		return fmt.Sprintf("\"%s\"", escapeQuotes.Replace(v)), nil
 	case bool:
 		return strconv.FormatBool(v), nil
-	case uint8:
+	case int8, uint8:
 		return fmt.Sprintf("%dB", v), nil
-	case int8, int16:
+	case int16:
 		return fmt.Sprintf("%dS", v), nil
 	case int32, uint16:
 		return fmt.Sprintf("%d", v), nil
@@ -130,7 +140,7 @@ func (gl *GremlinLang) argAsString(arg interface{}) (string, error) {
 		return fmt.Sprintf("%dN", v), nil
 	case float32:
 		if math.IsNaN(float64(v)) {
-			return "Nan", nil
+			return "NaN", nil
 		}
 		if math.IsInf(float64(v), 1) {
 			return "Infinity", nil
@@ -141,7 +151,7 @@ func (gl *GremlinLang) argAsString(arg interface{}) (string, error) {
 		return fmt.Sprintf("%vF", v), nil
 	case float64:
 		if math.IsNaN(v) {
-			return "Nan", nil
+			return "NaN", nil
 		}
 		if math.IsInf(v, 1) {
 			return "Infinity", nil
@@ -151,14 +161,19 @@ func (gl *GremlinLang) argAsString(arg interface{}) (string, error) {
 		}
 		return fmt.Sprintf("%vD", v), nil
 	case *SimpleSet:
-		return gl.translateSlice(v.ToSlice())
-	case *BigDecimal, BigDecimal:
-		return fmt.Sprintf("%vM", v), nil
+		return gl.translateSet(v.ToSlice())
+	case BigDecimal:
+		return fmt.Sprintf("%vM", v.Value()), nil
+	case *BigDecimal:
+		return fmt.Sprintf("%vM", v.Value()), nil
 	case time.Time:
 		return fmt.Sprintf("datetime(\"%v\")", v.Format(time.RFC3339)), nil
-	case cardinality, column, direction, operator, order, pick, pop, barrier, scope, t, merge:
+	case cardinality, column, direction, operator, order, pick, pop, barrier, scope, t, merge, gType:
 		name := reflect.ValueOf(v).Type().Name()
 		return fmt.Sprintf("%s.%s", strings.ToUpper(name[:1])+name[1:], v), nil
+	case dt:
+		name := reflect.ValueOf(v).Type().Name()
+		return fmt.Sprintf("%s.%s", strings.ToUpper(name), v), nil
 	case *Vertex:
 		id, _ := gl.argAsString(v.Id)
 		return fmt.Sprintf("new ReferenceVertex(%s,\"%s\")", escapeQuotes.Replace(id), escapeQuotes.Replace(v.Label)), nil
@@ -223,6 +238,8 @@ func (gl *GremlinLang) argAsString(arg interface{}) (string, error) {
 			gl.parameters[key] = v.Value()
 		}
 		return key, nil
+	case uuid.UUID:
+		return fmt.Sprintf("UUID(\"%v\")", v.String()), nil
 	default:
 		switch reflect.TypeOf(arg).Kind() {
 		case reflect.Map:
@@ -269,8 +286,16 @@ func (gl *GremlinLang) translateMap(arg interface{}) (string, error) {
 }
 
 func (gl *GremlinLang) translateSlice(arg interface{}) (string, error) {
+	return gl.translateCollection(arg, "[", "]")
+}
+
+func (gl *GremlinLang) translateSet(arg interface{}) (string, error) {
+	return gl.translateCollection(arg, "{", "}")
+}
+
+func (gl *GremlinLang) translateCollection(arg interface{}, open, close string) (string, error) {
 	sb := strings.Builder{}
-	sb.WriteString("[")
+	sb.WriteString(open)
 	list := reflect.ValueOf(arg)
 
 	for i := 0; i < list.Len(); i++ {
@@ -283,82 +308,84 @@ func (gl *GremlinLang) translateSlice(arg interface{}) (string, error) {
 		}
 		sb.WriteString(vString)
 	}
-	sb.WriteString("]")
+	sb.WriteString(close)
 	return sb.String(), nil
 }
 
 func (gl *GremlinLang) translateTextPredicate(v *textP) (string, error) {
-	if v.operator == "" || len(v.values) == 0 {
+	if v.operator == "" && len(v.values) == 0 {
 		return "", nil
 	}
 
-	instructionString := ""
-	instructionString += v.operator
-	instructionString += "("
-	if len(v.values) == 1 {
-		argString, err := gl.argAsString(v.values[0])
-		if err != nil {
-			return "", err
-		}
-		instructionString += argString
-	} else if len(v.values) > 1 {
-		for index, arg := range v.values {
-			argString, err := gl.argAsString(arg)
-			if err != nil {
-				return "", err
-			}
+	if v.operator == "or" || v.operator == "and" {
+		return gl.translateConnPOp(v.operator, v.values, gl.getPredicateString)
+	}
+	return gl.translatePValue(v.operator, v.values)
+}
 
-			instructionString += argString
-			if index < len(v.values)-1 && argString != "" {
-				instructionString += ","
-			}
-		}
+func (gl *GremlinLang) translatePredicate(v *p) (string, error) {
+	if v.operator == "" && len(v.values) == 0 {
+		return "", nil
 	}
 
-	instructionString += ")"
+	if v.operator == "or" || v.operator == "and" {
+		return gl.translateConnPOp(v.operator, v.values, gl.getPredicateString)
+	}
+	return gl.translatePValue(v.operator, v.values)
+}
 
-	return instructionString, nil
+func (gl *GremlinLang) translateConnPOp(operator string, values []interface{}, translator func(interface{}) (string, error)) (string, error) {
+	arg1, err := translator(values[0])
+	if err != nil {
+		return "", err
+	}
+	arg2, err := translator(values[1])
+	if err != nil {
+		return "", err
+	}
+	return arg1 + "." + operator + "(" + arg2 + ")", nil
 }
 
-func (gl *GremlinLang) translatePredicate(v *p) (string, error) {
+func (gl *GremlinLang) getPredicateString(v interface{}) (string, error) {
+	if val, ok := v.(textP); ok {
+		return gl.translateTextPredicate(&val)
+	}
+	if val, ok := v.(*textP); ok {
+		return gl.translateTextPredicate(val)
+	}
+	if val, ok := v.(p); ok {
+		return gl.translatePredicate(&val)
+	}
+	return gl.translatePredicate(v.(*p))
+}
 
-	if v.operator == "" || len(v.values) == 0 {
-		return "", nil
+func (gl *GremlinLang) translatePValue(operator string, values []interface{}) (string, error) {
+	sb := strings.Builder{}
+	sb.WriteString(operator + "(")
+
+	if len(values) > 1 && operator != "between" && operator != "inside" {
+		sb.WriteString("[")
 	}
 
-	instructionString := ""
-	instructionString += v.operator
-	instructionString += "("
-	if len(v.values) == 1 {
-		argString, err := gl.argAsString(v.values[0])
+	for i, arg := range values {
+		argString, err := gl.argAsString(arg)
 		if err != nil {
 			return "", err
 		}
-		instructionString += argString
-	} else if len(v.values) > 1 {
-		if v.operator != "between" && v.operator != "inside" {
-			instructionString += "["
-		}
-		for index, arg := range v.values {
-			argString, err := gl.argAsString(arg)
-			if err != nil {
-				return "", err
-			}
-
-			instructionString += argString
-			if index < len(v.values)-1 && argString != "" {
-				instructionString += ","
-			}
-		}
-		if v.operator != "between" && v.operator != "inside" {
-			instructionString += "]"
+		sb.WriteString(argString)
+		if i < len(values)-1 && argString != "" {
+			sb.WriteString(",")
 		}
 	}
 
-	instructionString += ")"
+	if len(values) > 1 && operator != "between" && operator != "inside" {
+		sb.WriteString("]")
+	}
+	sb.WriteString(")")
 
-	return instructionString, nil
+	return sb.String(), nil
 }
+
 func (gl *GremlinLang) asParameter(arg interface{}) string {
 	paramName := fmt.Sprintf("_%d", gl.paramCount.Load())
 	gl.paramCount.Add(1)
@@ -394,11 +421,15 @@ func (gl *GremlinLang) Reset() {
 }
 
 func (gl *GremlinLang) AddSource(name string, arguments ...interface{}) {
-	if name == "withStrategies" && len(arguments) != 0 {
+	if (name == "withStrategies" || name == "withoutStrategies") && len(arguments) != 0 {
 		args := gl.buildStrategyArgs(arguments...)
 		// possible to have empty strategies list to send
 		if len(args) != 0 {
-			gl.gremlin = append(gl.gremlin, ".withStrategies(")
+			if name == "withoutStrategies" {
+				gl.gremlin = append(gl.gremlin, ".withoutStrategies(")
+			} else {
+				gl.gremlin = append(gl.gremlin, ".withStrategies(")
+			}
 			gl.gremlin = append(gl.gremlin, args)
 			gl.gremlin = append(gl.gremlin, ")")
 		}
@@ -476,8 +507,13 @@ func (gl *GremlinLang) flattenArguments(arguments ...interface{}) []interface{}
 		arg, ok := argument.([]interface{})
 		if ok {
 			for _, nestedArg := range arg {
-				converted, _ := gl.convertArgument(nestedArg)
-				flatArgs = append(flatArgs, converted)
+				_, isUUID := nestedArg.(uuid.UUID)
+				if isUUID {
+					flatArgs = append(flatArgs, nestedArg)
+				} else {
+					converted, _ := gl.convertArgument(nestedArg)
+					flatArgs = append(flatArgs, converted)
+				}
 			}
 		} else {
 			converted, _ := gl.convertArgument(argument)
@@ -510,6 +546,10 @@ func (gl *GremlinLang) convertArgument(arg interface{}) (interface{}, error) {
 			}
 			return newMap, nil
 		case reflect.Array, reflect.Slice:
+			_, isUUID := arg.(uuid.UUID)
+			if isUUID {
+				return arg, nil
+			}
 			argList := reflect.ValueOf(arg)
 			newList := make([]interface{}, argList.Len())
 			for i := 0; i < argList.Len(); i++ {
diff --git a/gremlin-go/driver/gremlinlang_test.go b/gremlin-go/driver/gremlinlang_test.go
index 450bb729ff..d462e9f77b 100644
--- a/gremlin-go/driver/gremlinlang_test.go
+++ b/gremlin-go/driver/gremlinlang_test.go
@@ -20,9 +20,12 @@ under the License.
 package gremlingo
 
 import (
+	"math"
 	"regexp"
 	"testing"
 	"time"
+
+	"github.com/google/uuid"
 )
 
 func Test_GremlinLang(t *testing.T) {
@@ -234,12 +237,6 @@ func Test_GremlinLang(t *testing.T) {
 			},
 			equals: "g.withSack(0).V(\"3\",\"5\").sack(Operator.sum).by(\"runways\").sack()",
 		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V("3").Values("runways").Store("x").V("4").Values("runways").Store("x").By(T__.Constant(1)).V("6").Store("x").By(T__.Constant(1)).Select("x").Unfold().Sum()
-			},
-			equals: "g.V(\"3\").values(\"runways\").store(\"x\").V(\"4\").values(\"runways\").store(\"x\").by(__.constant(1)).V(\"6\").store(\"x\").by(__.constant(1)).select(\"x\").unfold().sum()",
-		},
 		{
 			assert: func(g *GraphTraversalSource) *GraphTraversal {
 				return g.Inject(3, 4, 5)
@@ -641,6 +638,42 @@ func Test_GremlinLang(t *testing.T) {
 			},
 			equals: "g.V().has(\"p1\",null)",
 		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().HasLabel("person").Values("age").Is(P.Between(26, 30).Or(P.Gt(34)))
+			},
+			equals: "g.V().hasLabel(\"person\").values(\"age\").is(between(26,30).or(gt(34)))",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.Inject(1).AsNumber(GType.Double)
+			},
+			equals: "g.inject(1).asNumber(GType.DOUBLE)",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.Inject(uuid.MustParse("f47af10b-58cc-4372-a567-0f02b2f3d479"))
+			},
+			equals: "g.inject(UUID(\"f47af10b-58cc-4372-a567-0f02b2f3d479\"))",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().Filter(T__.Has("name", TextP.StartingWith("m").Or(TextP.StartingWith("p"))))
+			},
+			equals: "g.V().filter(__.has(\"name\",startingWith(\"m\").or(startingWith(\"p\"))))",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.V().Has("person", "age", P.Within())
+			},
+			equals: "g.V().has(\"person\",\"age\",within([]))",
+		},
+		{
+			assert: func(g *GraphTraversalSource) *GraphTraversal {
+				return g.Inject(math.NaN()).Is(P.Eq(math.NaN()))
+			},
+			equals: "g.inject(NaN).is(eq(NaN))",
+		},
 	}
 
 	var testsToRun []test
diff --git a/gremlin-go/driver/httpTransporter.go b/gremlin-go/driver/httpTransporter.go
index f11cc104e1..465b80d96e 100644
--- a/gremlin-go/driver/httpTransporter.go
+++ b/gremlin-go/driver/httpTransporter.go
@@ -22,12 +22,10 @@ package gremlingo
 import (
 	"bytes"
 	"compress/zlib"
-	"encoding/hex"
 	"errors"
 	"fmt"
 	"io"
 	"net/http"
-	"os"
 	"sync"
 )
 
@@ -101,8 +99,9 @@ func (transporter *HttpTransporter) Write(data []byte) error {
 		return err
 	}
 
-	str := hex.EncodeToString(all)
-	_, _ = fmt.Fprintf(os.Stdout, "Received response data : %s\n", str)
+	// TODO for debug, remove later, and check response handling
+	//str := hex.EncodeToString(all)
+	//_, _ = fmt.Fprintf(os.Stdout, "Received response data : %s\n", str)
 
 	fmt.Println("Sending response to responseChannel")
 	transporter.responseChannel <- all
diff --git a/gremlin-go/driver/logger.go b/gremlin-go/driver/logger.go
index eef29f9b07..f1f8c6986a 100644
--- a/gremlin-go/driver/logger.go
+++ b/gremlin-go/driver/logger.go
@@ -107,7 +107,6 @@ const (
 	creatingRequest              errorKey = "CREATING_REQUEST"
 	readComplete                 errorKey = "READ_COMPLETE"
 	submitStartedString          errorKey = "SUBMIT_STARTED_STRING"
-	submitStartedBytecode        errorKey = "SUBMIT_STARTED_BYTECODE"
 	failedToCloseInErrorCallback errorKey = "FAILED_TO_CLOSE_IN_ERROR_CALLBACK"
 	failedToWriteMessage         errorKey = "FAILED_TO_WRITE_MESSAGE"
 	failedToSetWriteDeadline     errorKey = "FAILED_TO_SET_WRITE_DEADLINE"
diff --git a/gremlin-go/driver/serializer.go b/gremlin-go/driver/serializer.go
index 5ef970a68f..1e1c7b2bf3 100644
--- a/gremlin-go/driver/serializer.go
+++ b/gremlin-go/driver/serializer.go
@@ -22,8 +22,6 @@ package gremlingo
 import (
 	"bytes"
 	"encoding/binary"
-	"fmt"
-	"os"
 	"sync"
 )
 
@@ -111,13 +109,16 @@ func (gs graphBinarySerializer) deserializeMessage(message []byte) (response, er
 		if err != nil {
 			return msg, err
 		}
-		_, _ = fmt.Fprintf(os.Stdout, "Deserializing data : %v\n", n)
+		// TODO for debug, remove later
+		//_, _ = fmt.Fprintf(os.Stdout, "Deserializing data : %v\n", n)
 		if n == EndOfStream() {
 			break
 		}
 		results = append(results, n)
 	}
-	_, _ = fmt.Fprintf(os.Stdout, "Deserialized results : %s\n", results)
+
+	// TODO for debug, remove later
+	//_, _ = fmt.Fprintf(os.Stdout, "Deserialized results : %s\n", results)
 	msg.responseResult.data = results
 	code := readUint32Safe(&message, &i)
 	msg.responseStatus.code = code
@@ -173,7 +174,7 @@ func initSerializers() {
 		propertyType:       propertyWriter,
 		vertexPropertyType: vertexPropertyWriter,
 		pathType:           pathWriter,
-		datetimeType:       timeWriter,
+		datetimeType:       dateTimeWriter,
 		durationType:       durationWriter,
 		directionType:      enumWriter,
 		gTypeType:          enumWriter,
@@ -209,7 +210,7 @@ func initDeserializers() {
 		byteBuffer: readByteBuffer,
 
 		// Date Time
-		datetimeType: timeReader,
+		datetimeType: dateTimeReader,
 		durationType: durationReader,
 
 		// Graph
diff --git a/gremlin-go/driver/strategies.go b/gremlin-go/driver/strategies.go
index 939f7ea741..c0d8b3b578 100644
--- a/gremlin-go/driver/strategies.go
+++ b/gremlin-go/driver/strategies.go
@@ -74,7 +74,7 @@ func OptionsStrategy(options ...map[string]interface{}) TraversalStrategy {
 	if len(options) > 0 {
 		optsMap = options[0]
 	}
-	return &traversalStrategy{name: "OptionsStrategy", configuration: options}
+	return &traversalStrategy{name: "OptionsStrategy", configuration: optsMap}
 }
 
 // PartitionStrategy partitions the Vertices, Edges and Vertex properties of a Graph into String named
@@ -210,21 +210,37 @@ type MatchAlgorithmStrategyConfig struct {
 }
 
 func ReferenceElementStrategy(options ...map[string]interface{}) TraversalStrategy {
-	return &traversalStrategy{name: "ReferenceElementStrategy", configuration: options[0]}
+	config := make(map[string]interface{})
+	if len(options) > 0 {
+		config = options[0]
+	}
+	return &traversalStrategy{name: "ReferenceElementStrategy", configuration: config}
 }
 
 func ComputerFinalizationStrategy(options ...map[string]interface{}) TraversalStrategy {
-	return &traversalStrategy{name: "ComputerFinalizationStrategy", configuration: options[0]}
+	config := make(map[string]interface{})
+	if len(options) > 0 {
+		config = options[0]
+	}
+	return &traversalStrategy{name: "ComputerFinalizationStrategy", configuration: config}
 }
 
 func ProfileStrategy(options ...map[string]interface{}) TraversalStrategy {
-	return &traversalStrategy{name: "ProfileStrategy", configuration: options[0]}
+	config := make(map[string]interface{})
+	if len(options) > 0 {
+		config = options[0]
+	}
+	return &traversalStrategy{name: "ProfileStrategy", configuration: config}
 }
 
 // Verification strategies
 
 func ComputerVerificationStrategy(options ...map[string]interface{}) TraversalStrategy {
-	return &traversalStrategy{name: "ComputerVerificationStrategy", configuration: options[0]}
+	config := make(map[string]interface{})
+	if len(options) > 0 {
+		config = options[0]
+	}
+	return &traversalStrategy{name: "ComputerVerificationStrategy", configuration: config}
 }
 
 // EdgeLabelVerificationStrategy does not allow Edge traversal steps to have no label specified.
@@ -290,14 +306,6 @@ func VertexProgramRestrictionStrategy() TraversalStrategy {
 	return &traversalStrategy{name: "VertexProgramRestrictionStrategy"}
 }
 
-func StandardVerificationStrategy() TraversalStrategy {
-	return &traversalStrategy{name: "StandardVerificationStrategy"}
-}
-
-func VertexProgramRestrictionStrategy() TraversalStrategy {
-	return &traversalStrategy{name: "VertexProgramRestrictionStrategy"}
-}
-
 // Optimization strategies
 
 // AdjacentToIncidentStrategy looks for Vertex- and value-emitting steps followed by a CountGlobalStep and replaces
@@ -387,7 +395,11 @@ func MatchPredicateStrategy() TraversalStrategy {
 }
 
 func MessagePassingReductionStrategy(options ...map[string]interface{}) TraversalStrategy {
-	return &traversalStrategy{name: "MessagePassingReductionStrategy", configuration: options[0]}
+	config := make(map[string]interface{})
+	if len(options) > 0 {
+		config = options[0]
+	}
+	return &traversalStrategy{name: "MessagePassingReductionStrategy", configuration: config}
 }
 
 // OrderLimitStrategy is an OLAP strategy that folds a RangeGlobalStep into a preceding
diff --git a/gremlin-go/driver/translator.go b/gremlin-go/driver/translator.go
deleted file mode 100644
index 10629a51c3..0000000000
--- a/gremlin-go/driver/translator.go
+++ /dev/null
@@ -1,365 +0,0 @@
-/*
-Licensed to the Apache Software Foundation (ASF) under one
-or more contributor license agreements.  See the NOTICE file
-distributed with this work for additional information
-regarding copyright ownership.  The ASF licenses this file
-to you under the Apache License, Version 2.0 (the
-"License"); you may not use this file except in compliance
-with the License.  You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
-*/
-
-package gremlingo
-
-import (
-	"fmt"
-	"reflect"
-	"strings"
-	"time"
-)
-
-type Translator interface {
-	Translate(bytecode *Bytecode) (string, error)
-}
-
-type translator struct {
-	source string
-}
-
-func NewTranslator(source string) Translator {
-	return &translator{source}
-}
-
-func (t *translator) Translate(bytecode *Bytecode) (string, error) {
-	return t.translate(bytecode, true)
-}
-
-func (t *translator) translate(bytecode *Bytecode, initial bool) (string, error) {
-	translated := ""
-
-	if initial {
-		translated += t.source
-		appendDot(&translated)
-	}
-
-	for _, instruction := range bytecode.sourceInstructions {
-		if len(instruction.arguments) == 0 {
-			continue
-		}
-
-		appendDot(&translated)
-
-		translatedInstruction, err := t.translateInstruction(instruction)
-		if err != nil {
-			return "", err
-		}
-		translated += translatedInstruction
-	}
-
-	appendDot(&translated)
-
-	for _, instruction := range bytecode.stepInstructions {
-
-		appendDot(&translated)
-
-		translatedInstruction, err := t.translateInstruction(instruction)
-		if err != nil {
-			return "", err
-		}
-		translated += translatedInstruction
-	}
-
-	return translated, nil
-}
-
-func (t *translator) translateInstruction(instruction instruction) (string, error) {
-	instructionString := fmt.Sprintf("%v(", instruction.operator)
-
-	for index, arg := range instruction.arguments {
-		if index > 0 {
-			instructionString += ","
-		}
-
-		if instruction.operator == "with" {
-			switch v := arg.(type) {
-			case int32, string:
-				translatedArg, err := t.translateWithOptions(v)
-				if err != nil {
-					return "", err
-				}
-				instructionString += translatedArg
-				continue
-			}
-		}
-
-		argString, err := t.toString(arg)
-		if err != nil {
-			return "", err
-		}
-		instructionString += argString
-
-	}
-
-	instructionString += ")"
-
-	return instructionString, nil
-}
-
-func (t *translator) translateWithOptions(arg interface{}) (string, error) {
-	if groovyWithOptions[arg] != "" {
-		return groovyWithOptions[arg], nil
-	}
-
-	return t.toString(arg)
-}
-
-func (t *translator) translateMap(arg interface{}, isClassParamsMap bool) (string, error) {
-	instructionString := ""
-	iter := reflect.ValueOf(arg).MapRange()
-
-	index := 0
-	for iter.Next() {
-		if index == 0 && !isClassParamsMap {
-			instructionString += "{"
-		}
-
-		k := iter.Key().Interface()
-		kString, err := t.toString(k)
-		if err != nil {
-			return "", err
-		}
-		if isClassParamsMap {
-			kString = strings.Replace(kString, "'", "", -1)
-		}
-		v := iter.Value().Interface()
-		vString, err := t.toString(v)
-		if err != nil {
-			return "", err
-		}
-		instructionString += fmt.Sprintf("%v:%v", kString, vString)
-
-		if index < reflect.ValueOf(arg).Len()-1 {
-			instructionString += ","
-		}
-
-		if index == reflect.ValueOf(arg).Len()-1 && !isClassParamsMap {
-			instructionString += "}"
-		}
-		index++
-
-	}
-
-	return instructionString, nil
-}
-
-func (t *translator) translateSlice(arg interface{}) (string, error) {
-	instructionString := "["
-	oldSlice := reflect.ValueOf(arg)
-	if oldSlice.Len() == 0 {
-		return "", nil
-	}
-
-	for i := 0; i < oldSlice.Len(); i++ {
-		if i > 0 {
-			instructionString += ","
-		}
-		instructionStepString, err := t.toString(oldSlice.Index(i).Interface())
-		if err != nil {
-			return "", err
-		}
-		instructionString += fmt.Sprintf("%v", instructionStepString)
-	}
-	instructionString += "]"
-
-	return instructionString, nil
-}
-
-func (t *translator) translateTextPredicate(v *textP) (string, error) {
-	if v.operator == "" || len(v.values) == 0 {
-		return "", nil
-	}
-
-	instructionString := ""
-	instructionString += v.operator
-	instructionString += "("
-	if len(v.values) == 1 {
-		argString, err := t.toString(v.values[0])
-		if err != nil {
-			return "", err
-		}
-		instructionString += argString
-	} else if len(v.values) > 1 {
-		for index, arg := range v.values {
-			argString, err := t.toString(arg)
-			if err != nil {
-				return "", err
-			}
-
-			instructionString += argString
-			if index < len(v.values)-1 && argString != "" {
-				instructionString += ","
-			}
-		}
-	}
-
-	instructionString += ")"
-
-	return instructionString, nil
-}
-
-func (t *translator) translatePredicate(v *p) (string, error) {
-
-	if v.operator == "" || len(v.values) == 0 {
-		return "", nil
-	}
-
-	instructionString := ""
-	instructionString += v.operator
-	instructionString += "("
-	if len(v.values) == 1 {
-		argString, err := t.toString(v.values[0])
-		if err != nil {
-			return "", err
-		}
-		instructionString += argString
-	} else if len(v.values) > 1 {
-		if v.operator != "between" && v.operator != "inside" {
-			instructionString += "["
-		}
-		for index, arg := range v.values {
-			argString, err := t.toString(arg)
-			if err != nil {
-				return "", err
-			}
-
-			instructionString += argString
-			if index < len(v.values)-1 && argString != "" {
-				instructionString += ","
-			}
-		}
-		if v.operator != "between" && v.operator != "inside" {
-			instructionString += "]"
-		}
-	}
-
-	instructionString += ")"
-
-	return instructionString, nil
-}
-
-func (t *translator) translateTraversalStrategy(v *traversalStrategy) (string, error) {
-
-	instructionString := ""
-	className := getGroovyClassName(v.name)
-	instructionString += fmt.Sprintf("new %v(", className)
-	instructionConfigurationString, err := t.translateMap(interface{}(v.configuration), true)
-	if err != nil {
-		return "", err
-	}
-	instructionString += instructionConfigurationString
-	instructionString += ")"
-
-	return instructionString, nil
-
-}
-
-func (t *translator) toString(arg interface{}) (string, error) {
-	if arg == nil {
-		return "null", nil
-	}
-	reflectedArg := reflect.TypeOf(arg)
-	switch reflectedArg.Kind() {
-
-	case reflect.Map:
-		return t.translateMap(arg, false)
-	case reflect.Slice:
-		return t.translateSlice(arg)
-	default:
-		switch v := arg.(type) {
-		case withOptions:
-			{
-				return groovyWithOptions[v], nil
-			}
-		case AnonymousTraversal:
-		case *AnonymousTraversal:
-			return t.toString(arg)
-		case *Binding:
-			return v.String(), nil
-		case GraphTraversal:
-		case *GraphTraversal:
-			return t.translate(v.Bytecode, false)
-		case traversalStrategy:
-		case *traversalStrategy:
-			return t.translateTraversalStrategy(v)
-		case *Bytecode:
-			return t.translate(v, false)
-		case textP:
-		case *textP:
-			return t.translateTextPredicate(v)
-		case p:
-		case *p:
-			return t.translatePredicate(v)
-		default:
-			{
-				switch v := arg.(type) {
-				case time.Time:
-					{
-						return timeToGroovyTime(v), nil
-					}
-				case string:
-					{
-						return fmt.Sprintf("'%v'", v), nil
-					}
-				default:
-					{
-						return fmt.Sprintf("%v", v), nil
-					}
-				}
-			}
-		}
-	}
-
-	return "", nil
-
-}
-
-func appendDot(s *string) {
-	if len(*s) == 0 {
-		return
-	}
-
-	if (*s)[len(*s)-1] != '.' {
-		*s += "."
-	}
-}
-
-func getGroovyClassName(classPath string) string {
-	classPathArray := strings.Split(classPath, ".")
-	return classPathArray[len(classPathArray)-1]
-}
-
-func timeToGroovyTime(t time.Time) string {
-	return fmt.Sprintf("new Date(%v,%v,%v,%v,%v,%v)", t.Year()-1900, int(t.Month()), t.Day(), t.Hour(), t.Minute(), t.Second())
-
-}
-
-var groovyWithOptions map[any]string = map[any]string{
-	WithOptions.Tokens:  "WithOptions.tokens",
-	WithOptions.None:    "WithOptions.none",
-	WithOptions.Ids:     "WithOptions.ids",
-	WithOptions.Labels:  "WithOptions.labels",
-	WithOptions.Keys:    "WithOptions.keys",
-	WithOptions.Values:  "WithOptions.values",
-	WithOptions.All:     "WithOptions.all",
-	WithOptions.Indexer: "WithOptions.indexer",
-	WithOptions.List:    "WithOptions.list",
-	WithOptions.Map:     "WithOptions.map",
-}
diff --git a/gremlin-go/driver/translator_test.go b/gremlin-go/driver/translator_test.go
deleted file mode 100644
index 8daa5ce312..0000000000
--- a/gremlin-go/driver/translator_test.go
+++ /dev/null
@@ -1,717 +0,0 @@
-/*
-Licensed to the Apache Software Foundation (ASF) under one
-or more contributor license agreements.  See the NOTICE file
-distributed with this work for additional information
-regarding copyright ownership.  The ASF licenses this file
-to you under the Apache License, Version 2.0 (the
-"License"); you may not use this file except in compliance
-with the License.  You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
-*/
-
-package gremlingo
-
-import (
-	"regexp"
-	"testing"
-	"time"
-)
-
-func Test_translator_Translate(t *testing.T) {
-	type test struct {
-		name                      string
-		assert                    func(g *GraphTraversalSource) *GraphTraversal
-		equals                    string
-		only                      bool
-		skip                      bool
-		wantErr                   bool
-		containsRandomClassParams bool
-	}
-	tests := []test{
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal { return g.V() },
-			equals: "g.V()",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal { return g.V("1", "2", "3", "4") },
-			equals: "g.V('1','2','3','4')",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal { return g.V("3").ValueMap(true) },
-			equals: "g.V('3').valueMap(true)",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal { return g.V().Constant(5) },
-			equals: "g.V().constant(5)",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal { return g.V().Constant(1.5) },
-			equals: "g.V().constant(1.5)",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal { return g.V().Constant("Hello") },
-			equals: "g.V().constant('Hello')",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal { return g.V().HasLabel("airport").Limit(5) },
-			equals: "g.V().hasLabel('airport').limit(5)",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal { return g.V().HasLabel(P.Within("a", "b", "c")) },
-			equals: "g.V().hasLabel(within(['a','b','c']))",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().HasLabel("airport", "continent").Out().Limit(5)
-			},
-			equals: "g.V().hasLabel('airport','continent').out().limit(5)",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().HasLabel("airport").Out().Values("code").Limit(5)
-			},
-			equals: "g.V().hasLabel('airport').out().values('code').limit(5)",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V("3").As("a").Out("route").Limit(10).Where(P.Eq("a")).By("region")
-			},
-			equals: "g.V('3').as('a').out('route').limit(10).where(eq('a')).by('region')",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V("3").Repeat(T__.Out("route").SimplePath()).Times(2).Path().By("code")
-			},
-			equals: "g.V('3').repeat(out('route').simplePath()).times(2).path().by('code')",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().HasLabel("airport").Out().Has("region", "US-TX").Values("code").Limit(5)
-			},
-			equals: "g.V().hasLabel('airport').out().has('region','US-TX').values('code').limit(5)",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().HasLabel("airport").Union(T__.Values("city"), T__.Values("region")).Limit(5)
-			},
-			equals: "g.V().hasLabel('airport').union(values('city'),values('region')).limit(5)",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal { return g.V("3").As("a").Out("route", "routes") },
-			equals: "g.V('3').as('a').out('route','routes')",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal { return g.V().Where(T__.Values("runways").Is(5)) },
-			equals: "g.V().where(values('runways').is(5))",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V("3").Repeat(T__.Out().SimplePath()).Until(T__.Has("code", "AGR")).Path().By("code").Limit(5)
-			},
-			equals: "g.V('3').repeat(out().simplePath()).until(has('code','AGR')).path().by('code').limit(5)",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal { return g.V().HasLabel("airport").Order().By(T__.Id()) },
-			equals: "g.V().hasLabel('airport').order().by(id())",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal { return g.V().HasLabel("airport").Order().By(T.Id) },
-			equals: "g.V().hasLabel('airport').order().by(id)",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().HasLabel("airport").Order().By(T__.Id(), Order.Desc)
-			},
-			equals: "g.V().hasLabel('airport').order().by(id(),desc)",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().HasLabel("airport").Order().By("code", Order.Desc)
-			},
-			equals: "g.V().hasLabel('airport').order().by('code',desc)",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V("1", "2", "3").Local(T__.Out().Out().Dedup().Fold())
-			},
-			equals: "g.V('1','2','3').local(out().out().dedup().fold())",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V("3").Out().Path().Count(Scope.Local)
-			},
-			equals: "g.V('3').out().path().count(local)",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.E().Count()
-			},
-			equals: "g.E().count()",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V("5").OutE("route").InV().Path().Limit(10)
-			},
-			equals: "g.V('5').outE('route').inV().path().limit(10)",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V("5").PropertyMap().Select(Column.Keys)
-			},
-			equals: "g.V('5').propertyMap().select(keys)",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V("5").PropertyMap().Select(Column.Values)
-			},
-			equals: "g.V('5').propertyMap().select(values)",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V("3").Values("runways").Math("_ + 1")
-			},
-			equals: "g.V('3').values('runways').math('_ + 1')",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V("3").Emit().Repeat(T__.Out().SimplePath()).Times(3).Limit(5).Path()
-			},
-			equals: "g.V('3').emit().repeat(out().simplePath()).times(3).limit(5).path()",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().Match(T__.As("a").Has("code", "LHR").As("b")).Select("b").By("code")
-			},
-			equals: "g.V().match(as('a').has('code','LHR').as('b')).select('b').by('code')",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().Has("test-using-keyword-as-property", "repeat")
-			},
-			equals: "g.V().has('test-using-keyword-as-property','repeat')",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V("1").AddE("test").To(T__.V("4"))
-			},
-			equals: "g.V('1').addE('test').to(V('4'))",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().Values("runways").Max()
-			},
-			equals: "g.V().values('runways').max()",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().Values("runways").Min()
-			},
-			equals: "g.V().values('runways').min()",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().Values("runways").Sum()
-			},
-			equals: "g.V().values('runways').sum()",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().Values("runways").Mean()
-			},
-			equals: "g.V().values('runways').mean()",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.WithSack(0).V("3", "5").Sack(Operator.Sum).By("runways").Sack()
-			},
-			equals: "g.withSack(0).V('3','5').sack(sum).by('runways').sack()",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.Inject(3, 4, 5)
-			},
-			equals: "g.inject(3,4,5)",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.Inject([]interface{}{3, 4, 5})
-			},
-			equals: "g.inject([3,4,5])",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.Inject(3, 4, 5).Count()
-			},
-			equals: "g.inject(3,4,5).count()",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().Has("runways", P.Gt(5)).Count()
-			},
-			equals: "g.V().has('runways',gt(5)).count()",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().Has("runways", P.Lte(5.3)).Count()
-			},
-			equals: "g.V().has('runways',lte(5.3)).count()",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().Has("code", P.Within(123, 124))
-			},
-			equals: "g.V().has('code',within([123,124]))",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().Has("code", P.Within(123, "abc"))
-			},
-			equals: "g.V().has('code',within([123,'abc']))",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().Has("code", P.Within("abc", 123))
-			},
-			equals: "g.V().has('code',within(['abc',123]))",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().Has("code", P.Within("abc", "xyz"))
-			},
-			equals: "g.V().has('code',within(['abc','xyz']))",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V("1", "2").Has("region", P.Within("US-TX", "US-GA"))
-			},
-			equals: "g.V('1','2').has('region',within(['US-TX','US-GA']))",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().And(T__.Has("runways", P.Gt(5)), T__.Has("region", "US-TX"))
-			},
-			equals: "g.V().and(has('runways',gt(5)),has('region','US-TX'))",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().Union(T__.Has("runways", P.Gt(5)), T__.Has("region", "US-TX"))
-			},
-			equals: "g.V().union(has('runways',gt(5)),has('region','US-TX'))",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V("3").Choose(T__.Values("runways").Is(3), T__.Constant("three"), T__.Constant("not three"))
-			},
-			equals: "g.V('3').choose(values('runways').is(3),constant('three'),constant('not three'))",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V("3").Choose(T__.Values("runways")).Option(1, T__.Constant("three")).Option(2, T__.Constant("not three"))
-			},
-			equals: "g.V('3').choose(values('runways')).option(1,constant('three')).option(2,constant('not three'))",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V("3").Choose(T__.Values("runways")).Option(1.5, T__.Constant("one and a half")).Option(2, T__.Constant("not three"))
-			},
-			equals: "g.V('3').choose(values('runways')).option(1.5,constant('one and a half')).option(2,constant('not three'))",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V("3").Repeat(T__.Out().SimplePath()).Until(T__.Loops().Is(1)).Count()
-			},
-			equals: "g.V('3').repeat(out().simplePath()).until(loops().is(1)).count()",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().HasLabel("airport").Limit(20).Group().By("region").By("code").Order(Scope.Local).By(Column.Keys)
-			},
-			equals: "g.V().hasLabel('airport').limit(20).group().by('region').by('code').order(local).by(keys)",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V("1").As("a").V("2").As("a").Select(Pop.All, "a")
-			},
-			equals: "g.V('1').as('a').V('2').as('a').select(all,'a')",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.AddV("test").Property(Cardinality.Set, "p1", 10)
-			},
-			equals: "g.addV('test').property(set,'p1',10)",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.AddV("test").Property(Cardinality.List, "p1", 10)
-			},
-			equals: "g.addV('test').property(list,'p1',10)",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.AddV("test").Property(Cardinality.Single, "p1", 10)
-			},
-			equals: "g.addV('test').property(single,'p1',10)",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().Limit(5).Order().By(T__.Label())
-			},
-			equals: "g.V().limit(5).order().by(label())",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().Range(1, 5)
-			},
-			equals: "g.V().range(1,5)",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.AddV("test").Property("p1", 123)
-			},
-			equals: "g.addV('test').property('p1',123)",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().Has("date", P.Gt(time.Date(2021, 1, 1, 9, 30, 0, 0, time.UTC)))
-			},
-			equals: "g.V().has('date',gt(new Date(121,1,1,9,30,0)))",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.AddE("route").From(T__.V("1")).To(T__.V("2"))
-			},
-			equals: "g.addE('route').from(V('1')).to(V('2'))",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.WithSideEffect("a", []interface{}{1, 2}).V("3").Select("a")
-			},
-			equals: "g.withSideEffect('a',[1,2]).V('3').select('a')",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.WithSideEffect("a", 1).V("3").Select("a")
-			},
-			equals: "g.withSideEffect('a',1).V('3').select('a')",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.WithSideEffect("a", "abc").V("3").Select("a")
-			},
-			equals: "g.withSideEffect('a','abc').V('3').select('a')",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().Has("airport", "region", "US-NM").Limit(3).Values("elev").Fold().Index()
-			},
-			equals: "g.V().has('airport','region','US-NM').limit(3).values('elev').fold().index()",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V("3").Repeat(T__.TimeLimit(1000).Out().SimplePath()).Until(T__.Has("code", "AGR")).Path()
-			},
-			equals: "g.V('3').repeat(timeLimit(1000).out().simplePath()).until(has('code','AGR')).path()",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().HasLabel("airport").Where(T__.Values("elev").Is(P.Gt(14000)))
-			},
-			equals: "g.V().hasLabel('airport').where(values('elev').is(gt(14000)))",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().HasLabel("airport").Where(T__.Out().Count().Is(P.Gt(250))).Values("code")
-			},
-			equals: "g.V().hasLabel('airport').where(out().count().is(gt(250))).values('code')",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().HasLabel("airport").Filter(T__.Out().Count().Is(P.Gt(250))).Values("code")
-			},
-			equals: "g.V().hasLabel('airport').filter(out().count().is(gt(250))).values('code')",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.WithSack(0).
-					V("3").
-					Repeat(T__.OutE("route").Sack(Operator.Sum).By("dist").InV()).
-					Until(T__.Has("code", "AGR").Or().Loops().Is(4)).
-					Has("code", "AGR").
-					Local(T__.Union(T__.Path().By("code").By("dist"), T__.Sack()).Fold()).
-					Limit(10)
-			},
-			equals: "g.withSack(0).V('3').repeat(outE('route').sack(sum).by('dist').inV()).until(has('code','AGR').or().loops().is(4)).has('code','AGR').local(union(path().by('code').by('dist'),sack()).fold()).limit(10)",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.AddV().As("a").AddV().As("b").AddE("knows").From("a").To("b")
-			},
-			equals: "g.addV().as('a').addV().as('b').addE('knows').from('a').to('b')",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.AddV("Person").As("a").AddV("Person").As("b").AddE("knows").From("a").To("b")
-			},
-			equals: "g.addV('Person').as('a').addV('Person').as('b').addE('knows').from('a').to('b')",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V("3").Project("Out", "In").By(T__.Out().Count()).By(T__.In().Count())
-			},
-			equals: "g.V('3').project('Out','In').by(out().count()).by(in().count())",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V("44").Out().Aggregate("a").Out().Where(P.Within("a")).Path()
-			},
-			equals: "g.V('44').out().aggregate('a').out().where(within('a')).path()",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().Has("date", time.Date(2021, 2, 22, 0, 0, 0, 0, time.UTC))
-			},
-			equals: "g.V().has('date',new Date(121,2,22,0,0,0))",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().Has("date", P.Within(time.Date(2021, 2, 22, 0, 0, 0, 0, time.UTC), time.Date(2021, 1, 1, 0, 0, 0, 0, time.UTC)))
-			},
-			equals: "g.V().has('date',within([new Date(121,2,22,0,0,0),new Date(121,1,1,0,0,0)]))",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().Has("date", P.Between(time.Date(2021, 1, 1, 0, 0, 0, 0, time.UTC), time.Date(2021, 2, 22, 0, 0, 0, 0, time.UTC)))
-			},
-			equals: "g.V().has('date',between(new Date(121,1,1,0,0,0),new Date(121,2,22,0,0,0)))",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().Has("date", P.Inside(time.Date(2021, 1, 1, 0, 0, 0, 0, time.UTC), time.Date(2021, 2, 22, 0, 0, 0, 0, time.UTC)))
-			},
-			equals: "g.V().has('date',inside(new Date(121,1,1,0,0,0),new Date(121,2,22,0,0,0)))",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().Has("date", P.Gt(time.Date(2021, 1, 1, 9, 30, 0, 0, time.UTC)))
-			},
-			equals: "g.V().has('date',gt(new Date(121,1,1,9,30,0)))",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().Has("runways", P.Between(3, 5))
-			},
-			equals: "g.V().has('runways',between(3,5))",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().Has("runways", P.Inside(3, 5))
-			},
-			equals: "g.V().has('runways',inside(3,5))",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V("44").OutE().ElementMap()
-			},
-			equals: "g.V('44').outE().elementMap()",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V("44").ValueMap().By(T__.Unfold())
-			},
-			equals: "g.V('44').valueMap().by(unfold())",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V("44").ValueMap().With(WithOptions.Tokens, WithOptions.Labels)
-			},
-			equals: "g.V('44').valueMap().with(WithOptions.tokens,WithOptions.labels)",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V("44").ValueMap().With(WithOptions.All)
-			},
-			equals: "g.V('44').valueMap().with(WithOptions.all)",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V("44").ValueMap().With(WithOptions.Indexer)
-			},
-			equals: "g.V('44').valueMap().with(WithOptions.indexer)",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V("44").ValueMap().With(WithOptions.Tokens)
-			},
-			equals: "g.V('44').valueMap().with(WithOptions.tokens)",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.WithStrategies(ReadOnlyStrategy()).AddV("test")
-			},
-			equals: "g.withStrategies(new ReadOnlyStrategy()).addV('test')",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.WithStrategies(SubgraphStrategy(SubgraphStrategyConfig{Vertices: T__.Has("region", "US-TX"), Edges: T__.HasLabel("route")})).V().Count()
-			},
-			containsRandomClassParams: true,
-			equals:                    "g.withStrategies(new SubgraphStrategy(vertices:has('region','US-TX'),edges:hasLabel('route'))).V().count()",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.WithStrategies(SubgraphStrategy(SubgraphStrategyConfig{VertexProperties: T__.HasNot("runways")})).V().Count()
-			},
-			equals: "g.withStrategies(new SubgraphStrategy(vertexProperties:hasNot('runways'))).V().count()",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.WithStrategies(SubgraphStrategy(SubgraphStrategyConfig{Vertices: T__.Has("region", "US-TX"), VertexProperties: T__.HasNot("runways")})).V().Count()
-			},
-			containsRandomClassParams: true,
-			equals:                    "g.withStrategies(new SubgraphStrategy(vertices:has('region','US-TX'),vertexProperties:hasNot('runways'))).V().count()",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.WithStrategies(ReadOnlyStrategy(), SubgraphStrategy(SubgraphStrategyConfig{Vertices: T__.Has("region", "US-TX"), Edges: T__.HasLabel("route")})).V().Count()
-			},
-			containsRandomClassParams: true,
-			equals:                    "g.withStrategies(new ReadOnlyStrategy(),new SubgraphStrategy(vertices:has('region','US-TX'),edges:hasLabel('route'))).V().count()",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.WithStrategies(ReadOnlyStrategy(), SubgraphStrategy(SubgraphStrategyConfig{Vertices: T__.Has("region", "US-TX")})).V().Count()
-			},
-			equals: "g.withStrategies(new ReadOnlyStrategy(),new SubgraphStrategy(vertices:has('region','US-TX'))).V().count()",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.WithStrategies(OptionsStrategy(map[string]interface{}{"evaluationTimeout": 500})).V().Count()
-			},
-			equals: "g.withStrategies(new OptionsStrategy(evaluationTimeout:500)).V().count()",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.WithStrategies(PartitionStrategy(PartitionStrategyConfig{PartitionKey: "partition", WritePartition: "a", ReadPartitions: NewSimpleSet("a")})).AddV("test")
-			},
-			containsRandomClassParams: true,
-			equals:                    "g.withStrategies(new PartitionStrategy(includeMetaProperties:false,partitionKey:'partition',writePartition:'a',readPartitions:['a'])).addV('test')",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.WithStrategies(VertexProgramStrategy(VertexProgramStrategyConfig{})).V().ShortestPath().With("~tinkerpop.shortestPath.target", T__.Has("name", "peter"))
-			},
-			equals: "g.withStrategies(new VertexProgramStrategy()).V().shortestPath().with('~tinkerpop.shortestPath.target',has('name','peter'))",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().Has("p1", TextP.StartingWith("foo"))
-			},
-			equals: "g.V().has('p1',startingWith('foo'))",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().Has("p1", TextP.EndingWith("foo"))
-			},
-			equals: "g.V().has('p1',endingWith('foo'))",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().Has("p1", TextP.Containing("foo"))
-			},
-			equals: "g.V().has('p1',containing('foo'))",
-		},
-		{
-			assert: func(g *GraphTraversalSource) *GraphTraversal {
-				return g.V().Has("p1", nil)
-			},
-			equals: "g.V().has('p1',null)",
-		},
-	}
-
-	var testsToRun []test
-
-	onlyTests := make([]test, 0)
-	for _, tt := range tests {
-		if tt.only {
-			onlyTests = append(onlyTests, tt)
-		}
-	}
-
-	if len(onlyTests) > 0 {
-		testsToRun = onlyTests
-	} else {
-		testsToRun = tests
-	}
-
-	for _, tt := range testsToRun {
-		if tt.skip {
-			continue
-		}
-
-		testName := tt.name
-		if testName == "" {
-			testName = tt.equals
-		}
-
-		t.Run(testName, func(t *testing.T) {
-			tr := &translator{
-				source: "g",
-			}
-			g := NewGraphTraversalSource(nil, nil)
-			bytecode := tt.assert(g).Bytecode
-			got, err := tr.Translate(bytecode)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("translator.Translate() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if !tt.containsRandomClassParams && got != tt.equals {
-				t.Errorf("translator.Translate() = %v, equals %v", got, tt.equals)
-			}
-
-			if tt.containsRandomClassParams {
-				equalsParams := getParams(tt.equals)
-				gotParams := getParams(got)
-
-				if len(equalsParams) != len(gotParams) {
-					t.Errorf("translator.Translate() = %v, equals %v", got, tt.equals)
-				}
-
-				for _, equalsParam := range equalsParams {
-					found := false
-					for _, gotParam := range gotParams {
-						if equalsParam == gotParam {
-							found = true
-							break
-						}
-					}
-					if !found {
-						t.Errorf("translator.Translate() = %v, equals %v", got, tt.equals)
-					}
-				}
-			}
-		})
-	}
-}
-
-func getParams(result string) []string {
-	pattern := `(\w+:.*?)`
-	re := regexp.MustCompile(pattern)
-	matches := re.FindAllStringSubmatch(result, -1)
-
-	params := make([]string, 0)
-	for _, match := range matches {
-		if len(match) > 0 {
-			params = append(params, match[0])
-		}
-	}
-
-	return params
-}
diff --git a/gremlin-go/driver/traversal.go b/gremlin-go/driver/traversal.go
index a1948e6aa6..b76862849d 100644
--- a/gremlin-go/driver/traversal.go
+++ b/gremlin-go/driver/traversal.go
@@ -33,7 +33,7 @@ type Traverser struct {
 // Traversal is the primary way in which graphs are processed.
 type Traversal struct {
 	graph       *Graph
-	Bytecode    *Bytecode
+	Bytecode    *Bytecode //TODO remove
 	GremlinLang *GremlinLang
 	remote      *DriverRemoteConnection
 	results     ResultSet
@@ -162,33 +162,33 @@ var Cardinality = cardinalities{
 }
 
 type cv struct {
-	Bytecode *Bytecode
+	GremlinLang *GremlinLang
 }
 
 type CardValue interface {
-	Single(val interface{}) Bytecode
-	Set(val interface{}) Bytecode
-	List(val interface{}) Bytecode
+	Single(val interface{}) GremlinLang
+	Set(val interface{}) GremlinLang
+	List(val interface{}) GremlinLang
 }
 
 var CardinalityValue CardValue = &cv{}
 
-func (*cv) Single(val interface{}) Bytecode {
-	bc := Bytecode{}
-	bc.AddSource("CardinalityValueTraversal", Cardinality.Single, val)
-	return bc
+func (*cv) Single(val interface{}) GremlinLang {
+	gl := GremlinLang{}
+	gl.AddSource("CardinalityValueTraversal", Cardinality.Single, val)
+	return gl
 }
 
-func (*cv) Set(val interface{}) Bytecode {
-	bc := Bytecode{}
-	bc.AddSource("CardinalityValueTraversal", Cardinality.Set, val)
-	return bc
+func (*cv) Set(val interface{}) GremlinLang {
+	gl := GremlinLang{}
+	gl.AddSource("CardinalityValueTraversal", Cardinality.Set, val)
+	return gl
 }
 
-func (*cv) List(val interface{}) Bytecode {
-	bc := Bytecode{}
-	bc.AddSource("CardinalityValueTraversal", Cardinality.List, val)
-	return bc
+func (*cv) List(val interface{}) GremlinLang {
+	gl := GremlinLang{}
+	gl.AddSource("CardinalityValueTraversal", Cardinality.List, val)
+	return gl
 }
 
 type column string
@@ -518,7 +518,7 @@ func newP(operator string, args ...interface{}) Predicate {
 	return &p{operator: operator, values: values}
 }
 
-func newPWithP(operator string, pp p, args ...interface{}) Predicate {
+func newPWithP(operator string, pp *p, args ...interface{}) Predicate {
 	values := make([]interface{}, 1)
 	values[0] = pp
 	values = append(values, args...)
@@ -606,12 +606,12 @@ func (*p) Without(args ...interface{}) Predicate {
 
 // And Predicate returns a Predicate composed of two predicates (logical AND of them).
 func (pp *p) And(args ...interface{}) Predicate {
-	return newPWithP("and", *pp, args...)
+	return newPWithP("and", pp, args...)
 }
 
 // Or Predicate returns a Predicate composed of two predicates (logical OR of them).
 func (pp *p) Or(args ...interface{}) Predicate {
-	return newPWithP("or", *pp, args...)
+	return newPWithP("or", pp, args...)
 }
 
 type TextPredicate interface {
@@ -784,6 +784,18 @@ type BigDecimal struct {
 	UnscaledValue *big.Int
 }
 
+func (bd *BigDecimal) Value() *big.Float {
+	// Create the divisor: 10^scale
+	divisor := new(big.Int).Exp(big.NewInt(10), big.NewInt(int64(bd.Scale)), nil)
+
+	// Convert unscaled value and divisor to big.Float
+	unscaled := new(big.Float).SetInt(bd.UnscaledValue)
+	div := new(big.Float).SetInt(divisor)
+
+	// Divide: unscaledValue / 10^scale
+	return new(big.Float).Quo(unscaled, div)
+}
+
 // ParseBigDecimal creates a BigDecimal from a string value.
 func ParseBigDecimal(strValue string) *BigDecimal {
 	val := &BigDecimal{}
diff --git a/gremlin-go/driver/traversal_test.go b/gremlin-go/driver/traversal_test.go
index 97520bf76c..dff1876726 100644
--- a/gremlin-go/driver/traversal_test.go
+++ b/gremlin-go/driver/traversal_test.go
@@ -36,16 +36,16 @@ func TestTraversal(t *testing.T) {
 		clone := original.Clone().Out("knows")
 		cloneClone := clone.Clone().Out("created")
 
-		assert.Equal(t, 2, len(original.Bytecode.stepInstructions))
-		assert.Equal(t, 3, len(clone.Bytecode.stepInstructions))
-		assert.Equal(t, 4, len(cloneClone.Bytecode.stepInstructions))
+		assert.Equal(t, "g.V().out(\"created\")", original.GremlinLang.GetGremlin())
+		assert.Equal(t, "g.V().out(\"created\").out(\"knows\")", clone.GremlinLang.GetGremlin())
+		assert.Equal(t, "g.V().out(\"created\").out(\"knows\").out(\"created\")", cloneClone.GremlinLang.GetGremlin())
 
 		original.Has("person", "name", "marko")
 		clone.V().Out()
 
-		assert.Equal(t, 3, len(original.Bytecode.stepInstructions))
-		assert.Equal(t, 5, len(clone.Bytecode.stepInstructions))
-		assert.Equal(t, 4, len(cloneClone.Bytecode.stepInstructions))
+		assert.Equal(t, "g.V().out(\"created\").has(\"person\",\"name\",\"marko\")", original.GremlinLang.GetGremlin())
+		assert.Equal(t, "g.V().out(\"created\").out(\"knows\").V().out()", clone.GremlinLang.GetGremlin())
+		assert.Equal(t, "g.V().out(\"created\").out(\"knows\").out(\"created\")", cloneClone.GremlinLang.GetGremlin())
 	})
 
 	t.Run("Test Iterate with empty removeConnection", func(t *testing.T) {
@@ -524,7 +524,7 @@ func TestTraversal(t *testing.T) {
 	})
 
 	t.Run("Test should extract ID from Vertex", func(t *testing.T) {
-		g := cloneGraphTraversalSource(&Graph{}, NewBytecode(nil), nil)
+		g := cloneGraphTraversalSource(&Graph{}, NewGremlinLang(nil), nil)
 
 		// Test basic V() step with mixed ID types
 		vStart := g.V(1, &Vertex{Element: Element{Id: 2}})
diff --git a/gremlin-go/examples/go.mod b/gremlin-go/examples/go.mod
index 20da81ee7d..6dd55e1afc 100644
--- a/gremlin-go/examples/go.mod
+++ b/gremlin-go/examples/go.mod
@@ -26,6 +26,6 @@ replace github.com/apache/tinkerpop/gremlin-go/v3 => ../
 require (
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/gorilla/websocket v1.5.3 // indirect
-	github.com/nicksnyder/go-i18n/v2 v2.5.0 // indirect
-	golang.org/x/text v0.21.0 // indirect
+	github.com/nicksnyder/go-i18n/v2 v2.6.0 // indirect
+	golang.org/x/text v0.32.0 // indirect
 )
diff --git a/gremlin-go/examples/go.sum b/gremlin-go/examples/go.sum
index b3d1c347c8..4d66940fd6 100644
--- a/gremlin-go/examples/go.sum
+++ b/gremlin-go/examples/go.sum
@@ -8,6 +8,7 @@ github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aN
 github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/nicksnyder/go-i18n/v2 v2.5.0 h1:3wH1gpaekcgGuwzWdSu7JwJhH9Tk87k1ezt0i1p2/Is=
 github.com/nicksnyder/go-i18n/v2 v2.5.0/go.mod h1:DrhgsSDZxoAfvVrBVLXoxZn/pN5TXqaDbq7ju94viiQ=
+github.com/nicksnyder/go-i18n/v2 v2.6.0/go.mod h1:88sRqr0C6OPyJn0/KRNaEz1uWorjxIKP7rUUcvycecE=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
@@ -16,5 +17,6 @@ github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsT
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
 golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
+golang.org/x/text v0.32.0/go.mod h1:o/rUWzghvpD5TXrTIBuJU77MTaN0ljMWE47kxGJQ7jY=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/gremlin-go/go.mod b/gremlin-go/go.mod
index 8b0e656723..c36ea3718d 100644
--- a/gremlin-go/go.mod
+++ b/gremlin-go/go.mod
@@ -20,22 +20,22 @@ module github.com/apache/tinkerpop/gremlin-go/v3
 go 1.25
 
 require (
-	github.com/cucumber/godog v0.15.0
+	github.com/cucumber/godog v0.15.1
 	github.com/google/uuid v1.6.0
-	github.com/nicksnyder/go-i18n/v2 v2.5.0
-	github.com/stretchr/testify v1.9.0
-	golang.org/x/text v0.21.0
+	github.com/nicksnyder/go-i18n/v2 v2.6.0
+	github.com/stretchr/testify v1.11.1
+	golang.org/x/text v0.32.0
 )
 
 require (
 	github.com/cucumber/gherkin/go/v26 v26.2.0 // indirect
 	github.com/cucumber/messages/go/v21 v21.0.1 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/gofrs/uuid v4.3.1+incompatible // indirect
+	github.com/gofrs/uuid v4.4.0+incompatible // indirect
 	github.com/hashicorp/go-immutable-radix v1.3.1 // indirect
-	github.com/hashicorp/go-memdb v1.3.4 // indirect
-	github.com/hashicorp/golang-lru v0.5.4 // indirect
+	github.com/hashicorp/go-memdb v1.3.5 // indirect
+	github.com/hashicorp/golang-lru v1.0.2 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/spf13/pflag v1.0.5 // indirect
+	github.com/spf13/pflag v1.0.10 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
diff --git a/gremlin-go/go.sum b/gremlin-go/go.sum
index 87eb5eae01..59675a75c5 100644
--- a/gremlin-go/go.sum
+++ b/gremlin-go/go.sum
@@ -1,10 +1,10 @@
-github.com/BurntSushi/toml v1.4.0 h1:kuoIxZQy2WRRk1pttg9asf+WVv6tWQuBNVmK8+nqPr0=
-github.com/BurntSushi/toml v1.4.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
+github.com/BurntSushi/toml v1.5.0 h1:W5quZX/G/csjUnuI8SUYlsHs9M38FC7znL0lIO+DvMg=
+github.com/BurntSushi/toml v1.5.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
 github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
 github.com/cucumber/gherkin/go/v26 v26.2.0 h1:EgIjePLWiPeslwIWmNQ3XHcypPsWAHoMCz/YEBKP4GI=
 github.com/cucumber/gherkin/go/v26 v26.2.0/go.mod h1:t2GAPnB8maCT4lkHL99BDCVNzCh1d7dBhCLt150Nr/0=
-github.com/cucumber/godog v0.15.0 h1:51AL8lBXF3f0cyA5CV4TnJFCTHpgiy+1x1Hb3TtZUmo=
-github.com/cucumber/godog v0.15.0/go.mod h1:FX3rzIDybWABU4kuIXLZ/qtqEe1Ac5RdXmqvACJOces=
+github.com/cucumber/godog v0.15.1 h1:rb/6oHDdvVZKS66hrhpjFQFHjthFSrQBCOI1LwshNTI=
+github.com/cucumber/godog v0.15.1/go.mod h1:qju+SQDewOljHuq9NSM66s0xEhogx0q30flfxL4WUk8=
 github.com/cucumber/messages/go/v21 v21.0.1 h1:wzA0LxwjlWQYZd32VTlAVDTkW6inOFmSM+RuOwHZiMI=
 github.com/cucumber/messages/go/v21 v21.0.1/go.mod h1:zheH/2HS9JLVFukdrsPWoPdmUtmYQAQPLk7w5vWsk5s=
 github.com/cucumber/messages/go/v22 v22.0.0/go.mod h1:aZipXTKc0JnjCsXrJnuZpWhtay93k7Rn3Dee7iyPJjs=
@@ -12,35 +12,40 @@ github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/gofrs/uuid v4.2.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
-github.com/gofrs/uuid v4.3.1+incompatible h1:0/KbAdpx3UXAx1kEOWHJeOkpbgRFGHVgv+CFIY7dBJI=
 github.com/gofrs/uuid v4.3.1+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
+github.com/gofrs/uuid v4.4.0+incompatible h1:3qXRTX8/NbyulANqlc0lchS1gqAVxRgsuW1YrTJupqA=
+github.com/gofrs/uuid v4.4.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/hashicorp/go-immutable-radix v1.3.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
 github.com/hashicorp/go-immutable-radix v1.3.1 h1:DKHmCUm2hRBK510BaiZlwvpD40f8bJFeZnpfm2KLowc=
 github.com/hashicorp/go-immutable-radix v1.3.1/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
-github.com/hashicorp/go-memdb v1.3.4 h1:XSL3NR682X/cVk2IeV0d70N4DZ9ljI885xAEU8IoK3c=
 github.com/hashicorp/go-memdb v1.3.4/go.mod h1:uBTr1oQbtuMgd1SSGoR8YV27eT3sBHbYiNm53bMpgSg=
+github.com/hashicorp/go-memdb v1.3.5 h1:b3taDMxCBCBVgyRrS1AZVHO14ubMYZB++QpNhBg+Nyo=
+github.com/hashicorp/go-memdb v1.3.5/go.mod h1:8IVKKBkVe+fxFgdFOYxzQQNjz+sWCyHCdIC/+5+Vy1Y=
 github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
 github.com/hashicorp/go-uuid v1.0.2 h1:cfejS+Tpcp13yd5nYHWDI6qVCny6wyX2Mt5SGur2IGE=
 github.com/hashicorp/go-uuid v1.0.2/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
 github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
-github.com/hashicorp/golang-lru v0.5.4 h1:YDjusn29QI/Das2iO9M0BHnIbxPeyuCHsjMW+lJfyTc=
 github.com/hashicorp/golang-lru v0.5.4/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
+github.com/hashicorp/golang-lru v1.0.2 h1:dV3g9Z/unq5DpblPpw+Oqcv4dU/1omnb4Ok8iPY6p1c=
+github.com/hashicorp/golang-lru v1.0.2/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
 github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI=
 github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/nicksnyder/go-i18n/v2 v2.5.0 h1:3wH1gpaekcgGuwzWdSu7JwJhH9Tk87k1ezt0i1p2/Is=
-github.com/nicksnyder/go-i18n/v2 v2.5.0/go.mod h1:DrhgsSDZxoAfvVrBVLXoxZn/pN5TXqaDbq7ju94viiQ=
+github.com/nicksnyder/go-i18n/v2 v2.6.0 h1:C/m2NNWNiTB6SK4Ao8df5EWm3JETSTIGNXBpMJTxzxQ=
+github.com/nicksnyder/go-i18n/v2 v2.6.0/go.mod h1:88sRqr0C6OPyJn0/KRNaEz1uWorjxIKP7rUUcvycecE=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/spf13/cobra v1.7.0/go.mod h1:uLxZILRyS/50WlhOIKD7W6V5bgeIt+4sICxh6uRMrb0=
-github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/pflag v1.0.7/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk=
+github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
@@ -48,10 +53,10 @@ github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
-github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
-golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+golang.org/x/text v0.32.0 h1:ZD01bjUt1FQ9WJ0ClOL5vxgxOI/sVCNgX1YtKwcY0mU=
+golang.org/x/text v0.32.0/go.mod h1:o/rUWzghvpD5TXrTIBuJU77MTaN0ljMWE47kxGJQ7jY=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
diff --git a/gremlin-python/src/main/python/gremlin_python/process/traversal.py b/gremlin-python/src/main/python/gremlin_python/process/traversal.py
index ba40b8d992..a90678098e 100644
--- a/gremlin-python/src/main/python/gremlin_python/process/traversal.py
+++ b/gremlin-python/src/main/python/gremlin_python/process/traversal.py
@@ -522,7 +522,7 @@ class TextP(P):
     def startingWith(*args):
         warnings.warn(
             "gremlin_python.process.TextP.startingWith will be replaced by "
-            "gremlin_python.process.TextP.startingWith.",
+            "gremlin_python.process.TextP.starting_with.",
             DeprecationWarning)
         return TextP("startingWith", *args)