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 2026/06/09 14:59:27 UTC

(tinkerpop) branch multi-label-experiment updated (788484c8d4 -> 477473f26f)

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

xiazcy pushed a change to branch multi-label-experiment
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git


 discard 788484c8d4 fix multi-label in transactions
 discard c725f659b5 Add some feature test
 discard 4077c555eb add a set of simple feature tests
 discard 0e1d79273a multilabel prototype
     add 9eca2f5b31 [TINKERPOP-3249] Remove sparql-gremlin (#3426)
     add c1e7b6afcb Refactor JS CI jobs to use matrix strategy and add Node 26 (#3425)
     add 6d0e2c259d Merge branch '3.7-dev' into 3.8-dev
     add 7175989121 Merge branch '3.8-dev'
     add d396815e4c TINKERPOP-3244 Add NextN(n) to Traversal in gremlin-go
     add ec32b0c4d5 TINKERPOP-3244 Wire NextN(n) into Go translators and document divergence
     add 584ada5d4d TINKERPOP-3244 Mention Go translator updates in CHANGELOG entry
     add a28cd1f2f1 Merge branch 'master' into improvement/TINKERPOP-3244-go-next-n
     add 40fa3ef90d [TINKERPOP-3244] Add NextN(n) to Traversal in gremlin-go (#3416)
     add c11d71b30d Add streaming HTTP response support to gremlin-driver (#3419)
     add cf0118a45c Add typed numeric wrappers and precise number mode to gremlin-javascript (#3427)
     add d129283e08 Fix Flaky .Net and server tests (#3431)
     add 8e49072e9f Fixed issues with dangling docker infrastructure (#3435)
     add ec6830fadd [INFRA] Set up default rulesets for default and release branches (#3429)
     add 86a0612c85 Fix port binding race between sequential GLV integration test runs
     add 06da5d4485 Enable autocommit in GremlinServer (#3423)
     add 8f88bba804 Subgraph support for GLVs (#3428)
     add 0afea960b9 Added to .gitignore CTR
     new 86b02d945c multilabel prototype
     new d7b15faeed add a set of simple feature tests
     new 85df245a2f Add some feature test
     new db8b034c26 fix multi-label in transactions
     new ebae853322 implement edge multi-label
     new 477473f26f GLV implementations

This update added new revisions after undoing existing revisions.
That is to say, some revisions that were in the old version of the
branch are not in the new version.  This situation occurs
when a user --force pushes a change and generates a repository
containing something like this:

 * -- * -- B -- O -- O -- O   (788484c8d4)
            \
             N -- N -- N   refs/heads/multi-label-experiment (477473f26f)

You should already have received notification emails for all of the O
revisions, and so the following emails describe only the N revisions
from the common base, B.

Any revisions marked "omit" are not gone; other references still
refer to them.  Any revisions marked "discard" are gone forever.

The 6 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.


Summary of changes:
 .asf.yaml                                          |  14 +-
 .github/workflows/build-test.yml                   |  40 +-
 .gitignore                                         |   1 +
 AGENTS.md                                          |  31 ++
 CHANGELOG.asciidoc                                 |   6 +
 docs/preprocessor/install-plugins.sh               |   2 +-
 docs/site/home/community.html                      |   4 -
 docs/src/dev/provider/index.asciidoc               |  28 +-
 docs/src/reference/compilers.asciidoc              | 440 -----------------
 docs/src/reference/gremlin-applications.asciidoc   |  22 +-
 docs/src/reference/gremlin-variants.asciidoc       | 116 ++++-
 docs/src/reference/index.asciidoc                  |   1 -
 docs/src/reference/intro.asciidoc                  |   3 +-
 docs/src/reference/the-traversal.asciidoc          |  10 +-
 docs/src/upgrade/release-4.x.x.asciidoc            |  75 +++
 .../grammar/DefaultGremlinBaseVisitor.java         |   8 +
 .../language/grammar/TraversalMethodVisitor.java   |  28 ++
 .../grammar/TraversalSourceSpawnMethodVisitor.java |  27 +-
 .../language/translator/GoTranslateVisitor.java    |  13 +
 .../traversal/dsl/graph/GraphTraversal.java        |  35 +-
 .../traversal/dsl/graph/GraphTraversalSource.java  |  52 +-
 .../gremlin/process/traversal/dsl/graph/__.java    |   7 +
 .../step/map/AbstractAddEdgeStepPlaceholder.java   |   5 +
 .../map/AbstractAddElementStepPlaceholder.java     |   7 +-
 .../step/map/AbstractAddVertexStepPlaceholder.java |   6 +
 .../traversal/step/map/AddEdgeStartStep.java       |  32 +-
 .../step/map/AddEdgeStartStepPlaceholder.java      |  10 +-
 .../process/traversal/step/map/AddEdgeStep.java    |  32 +-
 .../traversal/step/map/AddEdgeStepPlaceholder.java |  10 +-
 .../traversal/step/map/AddVertexStartStep.java     |  11 +
 .../step/map/AddVertexStartStepPlaceholder.java    |  10 +-
 .../process/traversal/step/map/AddVertexStep.java  |  11 +
 .../step/map/AddVertexStepPlaceholder.java         |  10 +-
 .../process/traversal/step/map/ElementMapStep.java |   6 +-
 .../process/traversal/step/map/MergeEdgeStep.java  | 113 ++++-
 .../traversal/step/map/PropertyMapStep.java        |   6 +-
 .../traversal/step/sideEffect/AddLabelStep.java    |  18 +-
 .../traversal/step/sideEffect/DropLabelsStep.java  |  18 +-
 .../process/traversal/step/util/WithOptions.java   |  18 +
 .../process/traversal/step/util/event/Event.java   |  26 +
 .../traversal/step/util/event/EventUtil.java       |  20 +
 .../structure/io/binary/types/EdgeSerializer.java  |  63 ++-
 .../structure/io/graphson/GraphSONModule.java      |  17 +-
 .../io/graphson/GraphSONSerializersV4.java         |  12 +-
 .../gremlin/structure/io/gryo/GryoVersion.java     |   3 +-
 .../structure/util/detached/DetachedEdge.java      |  34 ++
 .../structure/util/reference/ReferenceEdge.java    |  31 ++
 .../gremlin/structure/util/star/StarGraph.java     |  63 ++-
 .../language/translator/GremlinTranslatorTest.java |   2 +-
 .../Process/Traversal/GraphTraversal.cs            |  94 ++++
 .../Process/Traversal/GraphTraversalSource.cs      |  34 ++
 .../src/Gremlin.Net/Process/Traversal/__.cs        |  72 +++
 gremlin-dotnet/src/Gremlin.Net/Structure/Edge.cs   |  14 +-
 gremlin-dotnet/src/Gremlin.Net/Structure/Graph.cs  |  17 +
 .../Structure/IO/GraphBinary4/DataType.cs          |   3 +-
 .../IO/GraphBinary4/TypeSerializerRegistry.cs      |   2 +
 .../IO/GraphBinary4/Types/EdgeSerializer.cs        |  29 +-
 .../IO/GraphBinary4/Types/GraphSerializer.cs       | 225 +++++++++
 .../IO/GraphBinary4/Types/VertexSerializer.cs      |   9 +-
 gremlin-dotnet/src/Gremlin.Net/Structure/Vertex.cs |  13 +-
 .../Driver/PropertyDeserializationTests.cs         |   5 +
 .../Gherkin/CommonSteps.cs                         |  58 +++
 .../Gherkin/GherkinTestRunner.cs                   |  14 +-
 .../Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs |  32 +-
 .../Gherkin/IgnoreException.cs                     |   5 -
 .../DriverRemoteConnection/GraphTraversalTests.cs  |   1 +
 .../IO/GraphBinary4/GraphSerializerTests.cs        | 127 +++++
 gremlin-dotnet/test/pom.xml                        |  55 +--
 .../tinkerpop/gremlin/driver/Channelizer.java      |  44 +-
 .../apache/tinkerpop/gremlin/driver/Cluster.java   |  18 +
 .../tinkerpop/gremlin/driver/Connection.java       |  23 +-
 .../tinkerpop/gremlin/driver/ConnectionPool.java   |   1 +
 .../driver/handler/GremlinResponseHandler.java     |  21 +-
 .../handler/HttpStreamingResponseHandler.java      | 242 ++++++++++
 .../driver/stream/ByteBufQueueInputStream.java     | 137 ++++++
 .../stream/GraphBinaryStreamResponseReader.java    | 105 +++++
 .../gremlin/driver/stream/InputStreamBuffer.java   | 311 ++++++++++++
 .../handler/ByteBufQueueInputStreamTest.java       |  95 ++++
 .../GraphBinaryStreamResponseReaderTest.java       | 226 +++++++++
 .../handler/HttpStreamingResponseHandlerTest.java  | 207 ++++++++
 .../driver/handler/InputStreamBufferTest.java      |  94 ++++
 gremlin-go/driver/anonymousTraversal.go            |  28 ++
 gremlin-go/driver/cucumber/cucumberSteps_test.go   |  83 +++-
 gremlin-go/driver/cucumber/gremlin.go              |  28 ++
 gremlin-go/driver/graph.go                         |  23 +-
 gremlin-go/driver/graphBinaryDeserializer.go       | 202 +++++++-
 gremlin-go/driver/graphBinarySerializer.go         | 175 ++++++-
 gremlin-go/driver/graphBinarySerializer_test.go    | 184 ++++++++
 gremlin-go/driver/graphTraversal.go                |  24 +
 gremlin-go/driver/graph_test.go                    |  24 +-
 gremlin-go/driver/serializer.go                    |   1 +
 gremlin-go/driver/traversal.go                     |  25 +
 gremlin-go/driver/traversal_test.go                | 117 +++++
 gremlin-go/pom.xml                                 |  55 +--
 .../gremlin-javascript/lib/driver/connection.ts    |   5 +-
 gremlin-js/gremlin-javascript/lib/index.ts         |  12 +
 .../lib/language/translator/GoTranslateVisitor.ts  |  12 +
 .../lib/process/graph-traversal.ts                 |  44 ++
 .../gremlin-javascript/lib/process/gremlin-lang.ts |  26 +-
 .../gremlin-javascript/lib/structure/graph.ts      |  43 +-
 .../lib/structure/io/binary/GraphBinary.js         |  51 +-
 .../structure/io/binary/internals/AnySerializer.js |  12 +-
 .../io/binary/internals/EdgeSerializer.js          |  49 +-
 .../io/binary/internals/GraphSerializer.js         | 229 +++++++++
 .../internals/NumberSerializationStrategy.js       |  34 +-
 .../io/binary/internals/VertexSerializer.js        |  16 +-
 gremlin-js/gremlin-javascript/lib/utils.ts         | 156 +++++-
 gremlin-js/gremlin-javascript/pom.xml              |  56 +--
 .../test/cucumber/feature-steps.js                 |  54 ++-
 .../gremlin-javascript/test/cucumber/gremlin.js    |  28 ++
 gremlin-js/gremlin-javascript/test/helper.js       |   2 +
 .../test/integration/client-tests.js               |  33 +-
 .../gremlin-javascript/test/unit/exports-test.js   |  13 +
 .../test/unit/graph-serializer-test.js             | 194 ++++++++
 .../test/unit/graphbinary/precise-mode-test.js     | 521 +++++++++++++++++++++
 .../test/unit/graphbinary/typed-number-test.js     | 212 +++++++++
 .../test/unit/gremlin-lang-test.js                 | 134 +++++-
 .../unit/translator/gremlin-translator-test.js     |   3 +-
 gremlin-js/gremlin-mcp/src/translator/stepNames.ts |   8 +
 gremlin-language/src/main/antlr4/Gremlin.g4        |   8 +-
 gremlin-python/pom.xml                             |  27 +-
 .../gremlin_python/process/graph_traversal.py      | 119 +++++
 .../main/python/gremlin_python/structure/graph.py  |  28 +-
 .../gremlin_python/structure/io/graphbinaryV4.py   |  55 ++-
 .../src/main/python/tests/feature/gremlin.py       |  28 ++
 .../main/python/tests/unit/structure/test_graph.py |  14 +
 .../server/handler/HttpGremlinEndpointHandler.java |  51 +-
 .../gremlin/server/handler/HttpHandlerUtil.java    |   7 +
 .../GremlinDriverTransactionIntegrateTest.java     |  27 ++
 .../server/GremlinServerHttpIntegrateTest.java     |  91 +++-
 .../GremlinServerHttpTransactionIntegrateTest.java |  14 +-
 .../server/StreamingResponseIntegrateTest.java     | 239 ++++++++++
 .../gremlin/language/translator/translations.json  | 234 +++++++++
 .../gremlin/test/features/map/AddEdge.feature      |  34 +-
 .../gremlin/test/features/map/AsString.feature     |  14 +-
 .../gremlin/test/features/map/MergeEdge.feature    |   4 +-
 .../test/features/sideEffect/AddLabel.feature      |  16 +
 .../test/features/sideEffect/DropLabel.feature     |  32 ++
 .../ser/binary/TypeSerializerFailureTests.java     |   2 +-
 pom.xml                                            |   1 -
 sparql-gremlin/pom.xml                             |  69 ---
 .../apache/tinkerpop/gremlin/sparql/Prefixes.java  |  65 ---
 .../gremlin/sparql/SparqlToGremlinCompiler.java    | 318 -------------
 .../tinkerpop/gremlin/sparql/TraversalBuilder.java |  83 ----
 .../gremlin/sparql/WhereTraversalBuilder.java      | 128 -----
 .../gremlin/sparql/jsr223/SparqlGremlinPlugin.java |  63 ---
 .../dsl/sparql/DefaultSparqlTraversal.java         |  55 ---
 .../traversal/dsl/sparql/SparqlTraversal.java      |  62 ---
 .../dsl/sparql/SparqlTraversalSource.java          | 182 -------
 .../process/traversal/strategy/SparqlStrategy.java |  88 ----
 ...g.apache.tinkerpop.gremlin.jsr223.GremlinPlugin |   1 -
 .../tinkerpop/gremlin/sparql/PrefixesTest.java     |  67 ---
 .../dsl/sparql/SparqlTraversalSourceTest.java      | 189 --------
 .../src/test/resources/logback-silent.xml          |  26 -
 sparql-gremlin/src/test/resources/logback-test.xml |  26 -
 .../tinkergraph/structure/AbstractTinkerGraph.java |  20 +
 .../gremlin/tinkergraph/structure/TinkerEdge.java  |  89 +++-
 .../tinkergraph/structure/TinkerElement.java       |   2 +-
 .../gremlin/tinkergraph/structure/TinkerGraph.java |  30 ++
 .../structure/TinkerTransactionGraph.java          |  34 ++
 .../tinkergraph/structure/TinkerVertex.java        |  43 +-
 .../step/sideEffect/LabelMutationStepTest.java     |  16 +-
 .../structure/TinkerVertexMultiLabelTest.java      |  12 +-
 163 files changed, 7099 insertions(+), 2420 deletions(-)
 delete mode 100644 docs/src/reference/compilers.asciidoc
 create mode 100644 gremlin-dotnet/src/Gremlin.Net/Structure/IO/GraphBinary4/Types/GraphSerializer.cs
 create mode 100644 gremlin-dotnet/test/Gremlin.Net.UnitTest/Structure/IO/GraphBinary4/GraphSerializerTests.cs
 create mode 100644 gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/handler/HttpStreamingResponseHandler.java
 create mode 100644 gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/stream/ByteBufQueueInputStream.java
 create mode 100644 gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/stream/GraphBinaryStreamResponseReader.java
 create mode 100644 gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/stream/InputStreamBuffer.java
 create mode 100644 gremlin-driver/src/test/java/org/apache/tinkerpop/gremlin/driver/handler/ByteBufQueueInputStreamTest.java
 create mode 100644 gremlin-driver/src/test/java/org/apache/tinkerpop/gremlin/driver/handler/GraphBinaryStreamResponseReaderTest.java
 create mode 100644 gremlin-driver/src/test/java/org/apache/tinkerpop/gremlin/driver/handler/HttpStreamingResponseHandlerTest.java
 create mode 100644 gremlin-driver/src/test/java/org/apache/tinkerpop/gremlin/driver/handler/InputStreamBufferTest.java
 create mode 100644 gremlin-js/gremlin-javascript/lib/structure/io/binary/internals/GraphSerializer.js
 create mode 100644 gremlin-js/gremlin-javascript/test/unit/graph-serializer-test.js
 create mode 100644 gremlin-js/gremlin-javascript/test/unit/graphbinary/precise-mode-test.js
 create mode 100644 gremlin-js/gremlin-javascript/test/unit/graphbinary/typed-number-test.js
 create mode 100644 gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/StreamingResponseIntegrateTest.java
 delete mode 100644 sparql-gremlin/pom.xml
 delete mode 100644 sparql-gremlin/src/main/java/org/apache/tinkerpop/gremlin/sparql/Prefixes.java
 delete mode 100644 sparql-gremlin/src/main/java/org/apache/tinkerpop/gremlin/sparql/SparqlToGremlinCompiler.java
 delete mode 100644 sparql-gremlin/src/main/java/org/apache/tinkerpop/gremlin/sparql/TraversalBuilder.java
 delete mode 100644 sparql-gremlin/src/main/java/org/apache/tinkerpop/gremlin/sparql/WhereTraversalBuilder.java
 delete mode 100644 sparql-gremlin/src/main/java/org/apache/tinkerpop/gremlin/sparql/jsr223/SparqlGremlinPlugin.java
 delete mode 100644 sparql-gremlin/src/main/java/org/apache/tinkerpop/gremlin/sparql/process/traversal/dsl/sparql/DefaultSparqlTraversal.java
 delete mode 100644 sparql-gremlin/src/main/java/org/apache/tinkerpop/gremlin/sparql/process/traversal/dsl/sparql/SparqlTraversal.java
 delete mode 100644 sparql-gremlin/src/main/java/org/apache/tinkerpop/gremlin/sparql/process/traversal/dsl/sparql/SparqlTraversalSource.java
 delete mode 100644 sparql-gremlin/src/main/java/org/apache/tinkerpop/gremlin/sparql/process/traversal/strategy/SparqlStrategy.java
 delete mode 100644 sparql-gremlin/src/main/resources/META-INF/services/org.apache.tinkerpop.gremlin.jsr223.GremlinPlugin
 delete mode 100644 sparql-gremlin/src/test/java/org/apache/tinkerpop/gremlin/sparql/PrefixesTest.java
 delete mode 100644 sparql-gremlin/src/test/java/org/apache/tinkerpop/gremlin/sparql/process/traversal/dsl/sparql/SparqlTraversalSourceTest.java
 delete mode 100644 sparql-gremlin/src/test/resources/logback-silent.xml
 delete mode 100644 sparql-gremlin/src/test/resources/logback-test.xml


(tinkerpop) 04/06: fix multi-label in transactions

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

xiazcy pushed a commit to branch multi-label-experiment
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git

commit db8b034c2607133317fb0a13dcee732046f1003a
Author: Yang Xia <xi...@gmail.com>
AuthorDate: Thu May 14 13:41:10 2026 -0700

    fix multi-label in transactions
---
 .../gremlin/language/translator/translations.json  | 878 +++++++++++++++++++++
 .../structure/TinkerTransactionGraph.java          |   5 +-
 .../tinkergraph/structure/TinkerVertex.java        |  16 +
 3 files changed, 897 insertions(+), 2 deletions(-)

diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/language/translator/translations.json b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/language/translator/translations.json
index 3c9c17c495..c420bd491f 100644
--- a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/language/translator/translations.json
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/language/translator/translations.json
@@ -19290,6 +19290,76 @@
             }
         ]
     },
+    {
+        "scenario": "g_addVXa_bX_labels",
+        "traversals": [
+            {
+                "original": "g.addV(\"a\", \"b\").labels().fold()",
+                "language": "g.addV(\"a\", \"b\").labels().fold()",
+                "canonical": "g.addV(\"a\", \"b\").labels().fold()",
+                "anonymized": "g.addV(string0, string1).labels().fold()",
+                "dotnet": "g.AddV((string) \"a\", (string) \"b\").Labels().Fold()",
+                "go": "g.AddV(\"a\", \"b\").Labels().Fold()",
+                "groovy": "g.addV(\"a\", \"b\").labels().fold()",
+                "java": "g.addV(\"a\", \"b\").labels().fold()",
+                "javascript": "g.addV(\"a\", \"b\").labels().fold()",
+                "python": "g.add_v('a', 'b').labels().fold()"
+            },
+            {
+                "original": "g.V().hasLabel(\"a\").hasLabel(\"b\")",
+                "language": "g.V().hasLabel(\"a\").hasLabel(\"b\")",
+                "canonical": "g.V().hasLabel(\"a\").hasLabel(\"b\")",
+                "anonymized": "g.V().hasLabel(string0).hasLabel(string1)",
+                "dotnet": "g.V().HasLabel(\"a\").HasLabel(\"b\")",
+                "go": "g.V().HasLabel(\"a\").HasLabel(\"b\")",
+                "groovy": "g.V().hasLabel(\"a\").hasLabel(\"b\")",
+                "java": "g.V().hasLabel(\"a\").hasLabel(\"b\")",
+                "javascript": "g.V().hasLabel(\"a\").hasLabel(\"b\")",
+                "python": "g.V().has_label('a').has_label('b')"
+            },
+            {
+                "original": "g.addV(\"a\", \"b\")",
+                "language": "g.addV(\"a\", \"b\")",
+                "canonical": "g.addV(\"a\", \"b\")",
+                "anonymized": "g.addV(string0, string1)",
+                "dotnet": "g.AddV((string) \"a\", (string) \"b\")",
+                "go": "g.AddV(\"a\", \"b\")",
+                "groovy": "g.addV(\"a\", \"b\")",
+                "java": "g.addV(\"a\", \"b\")",
+                "javascript": "g.addV(\"a\", \"b\")",
+                "python": "g.add_v('a', 'b')"
+            },
+            {
+                "original": "g.V().labels()",
+                "language": "g.V().labels()",
+                "canonical": "g.V().labels()",
+                "anonymized": "g.V().labels()",
+                "dotnet": "g.V().Labels()",
+                "go": "g.V().Labels()",
+                "groovy": "g.V().labels()",
+                "java": "g.V().labels()",
+                "javascript": "g.V().labels()",
+                "python": "g.V().labels()"
+            }
+        ]
+    },
+    {
+        "scenario": "g_addVXa_b_cX_labels_count",
+        "traversals": [
+            {
+                "original": "g.addV(\"a\", \"b\", \"c\").labels().count()",
+                "language": "g.addV(\"a\", \"b\", \"c\").labels().count()",
+                "canonical": "g.addV(\"a\", \"b\", \"c\").labels().count()",
+                "anonymized": "g.addV(string0, string1, string2).labels().count()",
+                "dotnet": "g.AddV((string) \"a\", (string) \"b\", (string) \"c\").Labels().Count()",
+                "go": "g.AddV(\"a\", \"b\", \"c\").Labels().Count()",
+                "groovy": "g.addV(\"a\", \"b\", \"c\").labels().count()",
+                "java": "g.addV(\"a\", \"b\", \"c\").labels().count()",
+                "javascript": "g.addV(\"a\", \"b\", \"c\").labels().count()",
+                "python": "g.add_v('a', 'b', 'c').labels().count()"
+            }
+        ]
+    },
     {
         "scenario": "g_injectX1X_asBool",
         "traversals": [
@@ -24396,6 +24466,127 @@
             }
         ]
     },
+    {
+        "scenario": "g_V_hasLabelXpersonX_labels",
+        "traversals": [
+            {
+                "original": "g.V().hasLabel(\"person\").labels()",
+                "language": "g.V().hasLabel(\"person\").labels()",
+                "canonical": "g.V().hasLabel(\"person\").labels()",
+                "anonymized": "g.V().hasLabel(string0).labels()",
+                "dotnet": "g.V().HasLabel(\"person\").Labels()",
+                "go": "g.V().HasLabel(\"person\").Labels()",
+                "groovy": "g.V().hasLabel(\"person\").labels()",
+                "java": "g.V().hasLabel(\"person\").labels()",
+                "javascript": "g.V().hasLabel(\"person\").labels()",
+                "python": "g.V().has_label('person').labels()"
+            }
+        ]
+    },
+    {
+        "scenario": "g_addVXa_bX_labels_fold",
+        "traversals": [
+            {
+                "original": "g.addV(\"a\", \"b\")",
+                "language": "g.addV(\"a\", \"b\")",
+                "canonical": "g.addV(\"a\", \"b\")",
+                "anonymized": "g.addV(string0, string1)",
+                "dotnet": "g.AddV((string) \"a\", (string) \"b\")",
+                "go": "g.AddV(\"a\", \"b\")",
+                "groovy": "g.addV(\"a\", \"b\")",
+                "java": "g.addV(\"a\", \"b\")",
+                "javascript": "g.addV(\"a\", \"b\")",
+                "python": "g.add_v('a', 'b')"
+            },
+            {
+                "original": "g.V().labels().fold()",
+                "language": "g.V().labels().fold()",
+                "canonical": "g.V().labels().fold()",
+                "anonymized": "g.V().labels().fold()",
+                "dotnet": "g.V().Labels().Fold()",
+                "go": "g.V().Labels().Fold()",
+                "groovy": "g.V().labels().fold()",
+                "java": "g.V().labels().fold()",
+                "javascript": "g.V().labels().fold()",
+                "python": "g.V().labels().fold()"
+            }
+        ]
+    },
+    {
+        "scenario": "g_addVXa_bX_labels_count",
+        "traversals": [
+            {
+                "original": "g.addV(\"a\", \"b\")",
+                "language": "g.addV(\"a\", \"b\")",
+                "canonical": "g.addV(\"a\", \"b\")",
+                "anonymized": "g.addV(string0, string1)",
+                "dotnet": "g.AddV((string) \"a\", (string) \"b\")",
+                "go": "g.AddV(\"a\", \"b\")",
+                "groovy": "g.addV(\"a\", \"b\")",
+                "java": "g.addV(\"a\", \"b\")",
+                "javascript": "g.addV(\"a\", \"b\")",
+                "python": "g.add_v('a', 'b')"
+            },
+            {
+                "original": "g.V().labels().count()",
+                "language": "g.V().labels().count()",
+                "canonical": "g.V().labels().count()",
+                "anonymized": "g.V().labels().count()",
+                "dotnet": "g.V().Labels().Count()",
+                "go": "g.V().Labels().Count()",
+                "groovy": "g.V().labels().count()",
+                "java": "g.V().labels().count()",
+                "javascript": "g.V().labels().count()",
+                "python": "g.V().labels().count()"
+            }
+        ]
+    },
+    {
+        "scenario": "g_addV_labels",
+        "traversals": [
+            {
+                "original": "g.addV()",
+                "language": "g.addV()",
+                "canonical": "g.addV()",
+                "anonymized": "g.addV()",
+                "dotnet": "g.AddV()",
+                "go": "g.AddV()",
+                "groovy": "g.addV()",
+                "java": "g.addV()",
+                "javascript": "g.addV()",
+                "python": "g.add_v()"
+            },
+            {
+                "original": "g.V().labels()",
+                "language": "g.V().labels()",
+                "canonical": "g.V().labels()",
+                "anonymized": "g.V().labels()",
+                "dotnet": "g.V().Labels()",
+                "go": "g.V().Labels()",
+                "groovy": "g.V().labels()",
+                "java": "g.V().labels()",
+                "javascript": "g.V().labels()",
+                "python": "g.V().labels()"
+            }
+        ]
+    },
+    {
+        "scenario": "g_E_labels",
+        "traversals": [
+            {
+                "original": "g.E().hasLabel(\"knows\").labels()",
+                "language": "g.E().hasLabel(\"knows\").labels()",
+                "canonical": "g.E().hasLabel(\"knows\").labels()",
+                "anonymized": "g.E().hasLabel(string0).labels()",
+                "dotnet": "g.E().HasLabel(\"knows\").Labels()",
+                "go": "g.E().HasLabel(\"knows\").Labels()",
+                "groovy": "g.E().hasLabel(\"knows\").labels()",
+                "java": "g.E().hasLabel(\"knows\").labels()",
+                "javascript": "g.E().hasLabel(\"knows\").labels()",
+                "python": "g.E().has_label('knows').labels()"
+            }
+        ]
+    },
     {
         "scenario": "g_injectXfeature_test_nullX_length",
         "traversals": [
@@ -32249,6 +32440,454 @@
             }
         ]
     },
+    {
+        "scenario": "g_mergeVXlabel_ab_name_markoX_multilabel_create",
+        "traversals": [
+            {
+                "original": "g.mergeV([(T.label): [\"person\",\"employee\"], name: \"marko\"])",
+                "language": "g.mergeV([(T.label):[\"person\", \"employee\"], name:\"marko\"])",
+                "canonical": "g.mergeV([(T.label):[\"person\", \"employee\"], name:\"marko\"])",
+                "anonymized": "g.mergeV(map0)",
+                "dotnet": "g.MergeV((IDictionary<object, object>) new Dictionary<object, object> {{ T.Label, new List<object> { \"person\", \"employee\" } }, { \"name\", \"marko\" }})",
+                "go": "g.MergeV(map[interface{}]interface{}{gremlingo.T.Label: []interface{}{\"person\", \"employee\"}, \"name\": \"marko\" })",
+                "groovy": "g.mergeV([(T.label):[\"person\", \"employee\"], name:\"marko\"])",
+                "java": "g.mergeV(new LinkedHashMap<Object, Object>() {{ put(T.label, new ArrayList<Object>() {{ add(\"person\"); add(\"employee\"); }}); put(\"name\", \"marko\"); }})",
+                "javascript": "g.mergeV(new Map([[T.label, [\"person\", \"employee\"]], [\"name\", \"marko\"]]))",
+                "python": "g.merge_v({ T.label: ['person', 'employee'], 'name': 'marko' })"
+            },
+            {
+                "original": "g.V()",
+                "language": "g.V()",
+                "canonical": "g.V()",
+                "anonymized": "g.V()",
+                "dotnet": "g.V()",
+                "go": "g.V()",
+                "groovy": "g.V()",
+                "java": "g.V()",
+                "javascript": "g.V()",
+                "python": "g.V()"
+            },
+            {
+                "original": "g.V().hasLabel(\"person\").hasLabel(\"employee\")",
+                "language": "g.V().hasLabel(\"person\").hasLabel(\"employee\")",
+                "canonical": "g.V().hasLabel(\"person\").hasLabel(\"employee\")",
+                "anonymized": "g.V().hasLabel(string0).hasLabel(string1)",
+                "dotnet": "g.V().HasLabel(\"person\").HasLabel(\"employee\")",
+                "go": "g.V().HasLabel(\"person\").HasLabel(\"employee\")",
+                "groovy": "g.V().hasLabel(\"person\").hasLabel(\"employee\")",
+                "java": "g.V().hasLabel(\"person\").hasLabel(\"employee\")",
+                "javascript": "g.V().hasLabel(\"person\").hasLabel(\"employee\")",
+                "python": "g.V().has_label('person').has_label('employee')"
+            },
+            {
+                "original": "g.V().has(\"name\",\"marko\")",
+                "language": "g.V().has(\"name\", \"marko\")",
+                "canonical": "g.V().has(\"name\", \"marko\")",
+                "anonymized": "g.V().has(string0, string1)",
+                "dotnet": "g.V().Has(\"name\", \"marko\")",
+                "go": "g.V().Has(\"name\", \"marko\")",
+                "groovy": "g.V().has(\"name\", \"marko\")",
+                "java": "g.V().has(\"name\", \"marko\")",
+                "javascript": "g.V().has(\"name\", \"marko\")",
+                "python": "g.V().has('name', 'marko')"
+            }
+        ]
+    },
+    {
+        "scenario": "g_mergeVXlabel_abc_name_testX_multilabel_create",
+        "traversals": [
+            {
+                "original": "g.mergeV([(T.label): [\"a\",\"b\",\"c\"], name: \"test\"])",
+                "language": "g.mergeV([(T.label):[\"a\", \"b\", \"c\"], name:\"test\"])",
+                "canonical": "g.mergeV([(T.label):[\"a\", \"b\", \"c\"], name:\"test\"])",
+                "anonymized": "g.mergeV(map0)",
+                "dotnet": "g.MergeV((IDictionary<object, object>) new Dictionary<object, object> {{ T.Label, new List<object> { \"a\", \"b\", \"c\" } }, { \"name\", \"test\" }})",
+                "go": "g.MergeV(map[interface{}]interface{}{gremlingo.T.Label: []interface{}{\"a\", \"b\", \"c\"}, \"name\": \"test\" })",
+                "groovy": "g.mergeV([(T.label):[\"a\", \"b\", \"c\"], name:\"test\"])",
+                "java": "g.mergeV(new LinkedHashMap<Object, Object>() {{ put(T.label, new ArrayList<Object>() {{ add(\"a\"); add(\"b\"); add(\"c\"); }}); put(\"name\", \"test\"); }})",
+                "javascript": "g.mergeV(new Map([[T.label, [\"a\", \"b\", \"c\"]], [\"name\", \"test\"]]))",
+                "python": "g.merge_v({ T.label: ['a', 'b', 'c'], 'name': 'test' })"
+            },
+            {
+                "original": "g.V()",
+                "language": "g.V()",
+                "canonical": "g.V()",
+                "anonymized": "g.V()",
+                "dotnet": "g.V()",
+                "go": "g.V()",
+                "groovy": "g.V()",
+                "java": "g.V()",
+                "javascript": "g.V()",
+                "python": "g.V()"
+            },
+            {
+                "original": "g.V().hasLabel(\"a\").hasLabel(\"b\").hasLabel(\"c\")",
+                "language": "g.V().hasLabel(\"a\").hasLabel(\"b\").hasLabel(\"c\")",
+                "canonical": "g.V().hasLabel(\"a\").hasLabel(\"b\").hasLabel(\"c\")",
+                "anonymized": "g.V().hasLabel(string0).hasLabel(string1).hasLabel(string2)",
+                "dotnet": "g.V().HasLabel(\"a\").HasLabel(\"b\").HasLabel(\"c\")",
+                "go": "g.V().HasLabel(\"a\").HasLabel(\"b\").HasLabel(\"c\")",
+                "groovy": "g.V().hasLabel(\"a\").hasLabel(\"b\").hasLabel(\"c\")",
+                "java": "g.V().hasLabel(\"a\").hasLabel(\"b\").hasLabel(\"c\")",
+                "javascript": "g.V().hasLabel(\"a\").hasLabel(\"b\").hasLabel(\"c\")",
+                "python": "g.V().has_label('a').has_label('b').has_label('c')"
+            }
+        ]
+    },
+    {
+        "scenario": "g_mergeVXlabel_person_name_markoX_single_label",
+        "traversals": [
+            {
+                "original": "g.mergeV([(T.label): \"person\", name: \"marko\"])",
+                "language": "g.mergeV([(T.label):\"person\", name:\"marko\"])",
+                "canonical": "g.mergeV([(T.label):\"person\", name:\"marko\"])",
+                "anonymized": "g.mergeV(map0)",
+                "dotnet": "g.MergeV((IDictionary<object, object>) new Dictionary<object, object> {{ T.Label, \"person\" }, { \"name\", \"marko\" }})",
+                "go": "g.MergeV(map[interface{}]interface{}{gremlingo.T.Label: \"person\", \"name\": \"marko\" })",
+                "groovy": "g.mergeV([(T.label):\"person\", name:\"marko\"])",
+                "java": "g.mergeV(new LinkedHashMap<Object, Object>() {{ put(T.label, \"person\"); put(\"name\", \"marko\"); }})",
+                "javascript": "g.mergeV(new Map([[T.label, \"person\"], [\"name\", \"marko\"]]))",
+                "python": "g.merge_v({ T.label: 'person', 'name': 'marko' })"
+            },
+            {
+                "original": "g.V()",
+                "language": "g.V()",
+                "canonical": "g.V()",
+                "anonymized": "g.V()",
+                "dotnet": "g.V()",
+                "go": "g.V()",
+                "groovy": "g.V()",
+                "java": "g.V()",
+                "javascript": "g.V()",
+                "python": "g.V()"
+            },
+            {
+                "original": "g.V().hasLabel(\"person\")",
+                "language": "g.V().hasLabel(\"person\")",
+                "canonical": "g.V().hasLabel(\"person\")",
+                "anonymized": "g.V().hasLabel(string0)",
+                "dotnet": "g.V().HasLabel(\"person\")",
+                "go": "g.V().HasLabel(\"person\")",
+                "groovy": "g.V().hasLabel(\"person\")",
+                "java": "g.V().hasLabel(\"person\")",
+                "javascript": "g.V().hasLabel(\"person\")",
+                "python": "g.V().has_label('person')"
+            },
+            {
+                "original": "g.V().has(\"name\",\"marko\")",
+                "language": "g.V().has(\"name\", \"marko\")",
+                "canonical": "g.V().has(\"name\", \"marko\")",
+                "anonymized": "g.V().has(string0, string1)",
+                "dotnet": "g.V().Has(\"name\", \"marko\")",
+                "go": "g.V().Has(\"name\", \"marko\")",
+                "groovy": "g.V().has(\"name\", \"marko\")",
+                "java": "g.V().has(\"name\", \"marko\")",
+                "javascript": "g.V().has(\"name\", \"marko\")",
+                "python": "g.V().has('name', 'marko')"
+            }
+        ]
+    },
+    {
+        "scenario": "g_mergeVXlabel_ab_name_markoX_multilabel_match",
+        "traversals": [
+            {
+                "original": "g.addV(\"person\").addLabel(\"employee\").property(\"name\", \"marko\")",
+                "language": "g.addV(\"person\").addLabel(\"employee\").property(\"name\", \"marko\")",
+                "canonical": "g.addV(\"person\").addLabel(\"employee\").property(\"name\", \"marko\")",
+                "anonymized": "g.addV(string0).addLabel(string1).property(string2, string3)",
+                "dotnet": "g.AddV((string) \"person\").AddLabel(\"employee\").Property(\"name\", \"marko\")",
+                "go": "g.AddV(\"person\").AddLabel(\"employee\").Property(\"name\", \"marko\")",
+                "groovy": "g.addV(\"person\").addLabel(\"employee\").property(\"name\", \"marko\")",
+                "java": "g.addV(\"person\").addLabel(\"employee\").property(\"name\", \"marko\")",
+                "javascript": "g.addV(\"person\").addLabel(\"employee\").property(\"name\", \"marko\")",
+                "python": "g.add_v('person').add_label('employee').property('name', 'marko')"
+            },
+            {
+                "original": "g.mergeV([(T.label): [\"person\",\"employee\"], name: \"marko\"])",
+                "language": "g.mergeV([(T.label):[\"person\", \"employee\"], name:\"marko\"])",
+                "canonical": "g.mergeV([(T.label):[\"person\", \"employee\"], name:\"marko\"])",
+                "anonymized": "g.mergeV(map0)",
+                "dotnet": "g.MergeV((IDictionary<object, object>) new Dictionary<object, object> {{ T.Label, new List<object> { \"person\", \"employee\" } }, { \"name\", \"marko\" }})",
+                "go": "g.MergeV(map[interface{}]interface{}{gremlingo.T.Label: []interface{}{\"person\", \"employee\"}, \"name\": \"marko\" })",
+                "groovy": "g.mergeV([(T.label):[\"person\", \"employee\"], name:\"marko\"])",
+                "java": "g.mergeV(new LinkedHashMap<Object, Object>() {{ put(T.label, new ArrayList<Object>() {{ add(\"person\"); add(\"employee\"); }}); put(\"name\", \"marko\"); }})",
+                "javascript": "g.mergeV(new Map([[T.label, [\"person\", \"employee\"]], [\"name\", \"marko\"]]))",
+                "python": "g.merge_v({ T.label: ['person', 'employee'], 'name': 'marko' })"
+            },
+            {
+                "original": "g.V()",
+                "language": "g.V()",
+                "canonical": "g.V()",
+                "anonymized": "g.V()",
+                "dotnet": "g.V()",
+                "go": "g.V()",
+                "groovy": "g.V()",
+                "java": "g.V()",
+                "javascript": "g.V()",
+                "python": "g.V()"
+            },
+            {
+                "original": "g.V().hasLabel(\"person\").hasLabel(\"employee\")",
+                "language": "g.V().hasLabel(\"person\").hasLabel(\"employee\")",
+                "canonical": "g.V().hasLabel(\"person\").hasLabel(\"employee\")",
+                "anonymized": "g.V().hasLabel(string0).hasLabel(string1)",
+                "dotnet": "g.V().HasLabel(\"person\").HasLabel(\"employee\")",
+                "go": "g.V().HasLabel(\"person\").HasLabel(\"employee\")",
+                "groovy": "g.V().hasLabel(\"person\").hasLabel(\"employee\")",
+                "java": "g.V().hasLabel(\"person\").hasLabel(\"employee\")",
+                "javascript": "g.V().hasLabel(\"person\").hasLabel(\"employee\")",
+                "python": "g.V().has_label('person').has_label('employee')"
+            }
+        ]
+    },
+    {
+        "scenario": "g_mergeVXlabel_ab_name_markoX_multilabel_nomatch",
+        "traversals": [
+            {
+                "original": "g.addV(\"person\").property(\"name\", \"marko\")",
+                "language": "g.addV(\"person\").property(\"name\", \"marko\")",
+                "canonical": "g.addV(\"person\").property(\"name\", \"marko\")",
+                "anonymized": "g.addV(string0).property(string1, string2)",
+                "dotnet": "g.AddV((string) \"person\").Property(\"name\", \"marko\")",
+                "go": "g.AddV(\"person\").Property(\"name\", \"marko\")",
+                "groovy": "g.addV(\"person\").property(\"name\", \"marko\")",
+                "java": "g.addV(\"person\").property(\"name\", \"marko\")",
+                "javascript": "g.addV(\"person\").property(\"name\", \"marko\")",
+                "python": "g.add_v('person').property('name', 'marko')"
+            },
+            {
+                "original": "g.mergeV([(T.label): [\"person\",\"employee\"], name: \"marko\"])",
+                "language": "g.mergeV([(T.label):[\"person\", \"employee\"], name:\"marko\"])",
+                "canonical": "g.mergeV([(T.label):[\"person\", \"employee\"], name:\"marko\"])",
+                "anonymized": "g.mergeV(map0)",
+                "dotnet": "g.MergeV((IDictionary<object, object>) new Dictionary<object, object> {{ T.Label, new List<object> { \"person\", \"employee\" } }, { \"name\", \"marko\" }})",
+                "go": "g.MergeV(map[interface{}]interface{}{gremlingo.T.Label: []interface{}{\"person\", \"employee\"}, \"name\": \"marko\" })",
+                "groovy": "g.mergeV([(T.label):[\"person\", \"employee\"], name:\"marko\"])",
+                "java": "g.mergeV(new LinkedHashMap<Object, Object>() {{ put(T.label, new ArrayList<Object>() {{ add(\"person\"); add(\"employee\"); }}); put(\"name\", \"marko\"); }})",
+                "javascript": "g.mergeV(new Map([[T.label, [\"person\", \"employee\"]], [\"name\", \"marko\"]]))",
+                "python": "g.merge_v({ T.label: ['person', 'employee'], 'name': 'marko' })"
+            },
+            {
+                "original": "g.V()",
+                "language": "g.V()",
+                "canonical": "g.V()",
+                "anonymized": "g.V()",
+                "dotnet": "g.V()",
+                "go": "g.V()",
+                "groovy": "g.V()",
+                "java": "g.V()",
+                "javascript": "g.V()",
+                "python": "g.V()"
+            }
+        ]
+    },
+    {
+        "scenario": "g_mergeVXlabel_person_name_markoX_optionXonMatch_label_managerX",
+        "traversals": [
+            {
+                "original": "g.addV(\"person\").addLabel(\"employee\").property(\"name\", \"marko\")",
+                "language": "g.addV(\"person\").addLabel(\"employee\").property(\"name\", \"marko\")",
+                "canonical": "g.addV(\"person\").addLabel(\"employee\").property(\"name\", \"marko\")",
+                "anonymized": "g.addV(string0).addLabel(string1).property(string2, string3)",
+                "dotnet": "g.AddV((string) \"person\").AddLabel(\"employee\").Property(\"name\", \"marko\")",
+                "go": "g.AddV(\"person\").AddLabel(\"employee\").Property(\"name\", \"marko\")",
+                "groovy": "g.addV(\"person\").addLabel(\"employee\").property(\"name\", \"marko\")",
+                "java": "g.addV(\"person\").addLabel(\"employee\").property(\"name\", \"marko\")",
+                "javascript": "g.addV(\"person\").addLabel(\"employee\").property(\"name\", \"marko\")",
+                "python": "g.add_v('person').add_label('employee').property('name', 'marko')"
+            },
+            {
+                "original": "g.mergeV([(T.label): \"person\", name: \"marko\"]).option(Merge.onMatch, [(T.label): \"manager\"])",
+                "language": "g.mergeV([(T.label):\"person\", name:\"marko\"]).option(Merge.onMatch, [(T.label):\"manager\"])",
+                "canonical": "g.mergeV([(T.label):\"person\", name:\"marko\"]).option(Merge.onMatch, [(T.label):\"manager\"])",
+                "anonymized": "g.mergeV(map0).option(Merge.onMatch, map1)",
+                "dotnet": "g.MergeV((IDictionary<object, object>) new Dictionary<object, object> {{ T.Label, \"person\" }, { \"name\", \"marko\" }}).Option(Merge.OnMatch, (IDictionary<object, object>) new Dictionary<object, object> {{ T.Label, \"manager\" }})",
+                "go": "g.MergeV(map[interface{}]interface{}{gremlingo.T.Label: \"person\", \"name\": \"marko\" }).Option(gremlingo.Merge.OnMatch, map[interface{}]interface{}{gremlingo.T.Label: \"manager\" })",
+                "groovy": "g.mergeV([(T.label):\"person\", name:\"marko\"]).option(Merge.onMatch, [(T.label):\"manager\"])",
+                "java": "g.mergeV(new LinkedHashMap<Object, Object>() {{ put(T.label, \"person\"); put(\"name\", \"marko\"); }}).option(Merge.onMatch, new LinkedHashMap<Object, Object>() {{ put(T.label, \"manager\"); }})",
+                "javascript": "g.mergeV(new Map([[T.label, \"person\"], [\"name\", \"marko\"]])).option(Merge.onMatch, new Map([[T.label, \"manager\"]]))",
+                "python": "g.merge_v({ T.label: 'person', 'name': 'marko' }).option(Merge.on_match, { T.label: 'manager' })"
+            },
+            {
+                "original": "g.V()",
+                "language": "g.V()",
+                "canonical": "g.V()",
+                "anonymized": "g.V()",
+                "dotnet": "g.V()",
+                "go": "g.V()",
+                "groovy": "g.V()",
+                "java": "g.V()",
+                "javascript": "g.V()",
+                "python": "g.V()"
+            },
+            {
+                "original": "g.V().hasLabel(\"manager\")",
+                "language": "g.V().hasLabel(\"manager\")",
+                "canonical": "g.V().hasLabel(\"manager\")",
+                "anonymized": "g.V().hasLabel(string0)",
+                "dotnet": "g.V().HasLabel(\"manager\")",
+                "go": "g.V().HasLabel(\"manager\")",
+                "groovy": "g.V().hasLabel(\"manager\")",
+                "java": "g.V().hasLabel(\"manager\")",
+                "javascript": "g.V().hasLabel(\"manager\")",
+                "python": "g.V().has_label('manager')"
+            },
+            {
+                "original": "g.V().hasLabel(\"person\")",
+                "language": "g.V().hasLabel(\"person\")",
+                "canonical": "g.V().hasLabel(\"person\")",
+                "anonymized": "g.V().hasLabel(string0)",
+                "dotnet": "g.V().HasLabel(\"person\")",
+                "go": "g.V().HasLabel(\"person\")",
+                "groovy": "g.V().hasLabel(\"person\")",
+                "java": "g.V().hasLabel(\"person\")",
+                "javascript": "g.V().hasLabel(\"person\")",
+                "python": "g.V().has_label('person')"
+            },
+            {
+                "original": "g.V().hasLabel(\"employee\")",
+                "language": "g.V().hasLabel(\"employee\")",
+                "canonical": "g.V().hasLabel(\"employee\")",
+                "anonymized": "g.V().hasLabel(string0)",
+                "dotnet": "g.V().HasLabel(\"employee\")",
+                "go": "g.V().HasLabel(\"employee\")",
+                "groovy": "g.V().hasLabel(\"employee\")",
+                "java": "g.V().hasLabel(\"employee\")",
+                "javascript": "g.V().hasLabel(\"employee\")",
+                "python": "g.V().has_label('employee')"
+            }
+        ]
+    },
+    {
+        "scenario": "g_mergeVXlabel_person_name_markoX_optionXonMatch_label_manager_directorX",
+        "traversals": [
+            {
+                "original": "g.addV(\"person\").property(\"name\", \"marko\")",
+                "language": "g.addV(\"person\").property(\"name\", \"marko\")",
+                "canonical": "g.addV(\"person\").property(\"name\", \"marko\")",
+                "anonymized": "g.addV(string0).property(string1, string2)",
+                "dotnet": "g.AddV((string) \"person\").Property(\"name\", \"marko\")",
+                "go": "g.AddV(\"person\").Property(\"name\", \"marko\")",
+                "groovy": "g.addV(\"person\").property(\"name\", \"marko\")",
+                "java": "g.addV(\"person\").property(\"name\", \"marko\")",
+                "javascript": "g.addV(\"person\").property(\"name\", \"marko\")",
+                "python": "g.add_v('person').property('name', 'marko')"
+            },
+            {
+                "original": "g.mergeV([(T.label): \"person\", name: \"marko\"]).option(Merge.onMatch, [(T.label): [\"manager\",\"director\"]])",
+                "language": "g.mergeV([(T.label):\"person\", name:\"marko\"]).option(Merge.onMatch, [(T.label):[\"manager\", \"director\"]])",
+                "canonical": "g.mergeV([(T.label):\"person\", name:\"marko\"]).option(Merge.onMatch, [(T.label):[\"manager\", \"director\"]])",
+                "anonymized": "g.mergeV(map0).option(Merge.onMatch, map1)",
+                "dotnet": "g.MergeV((IDictionary<object, object>) new Dictionary<object, object> {{ T.Label, \"person\" }, { \"name\", \"marko\" }}).Option(Merge.OnMatch, (IDictionary<object, object>) new Dictionary<object, object> {{ T.Label, new List<object> { \"manager\", \"director\" } }})",
+                "go": "g.MergeV(map[interface{}]interface{}{gremlingo.T.Label: \"person\", \"name\": \"marko\" }).Option(gremlingo.Merge.OnMatch, map[interface{}]interface{}{gremlingo.T.Label: []interface{}{\"manager\", \"director\"} })",
+                "groovy": "g.mergeV([(T.label):\"person\", name:\"marko\"]).option(Merge.onMatch, [(T.label):[\"manager\", \"director\"]])",
+                "java": "g.mergeV(new LinkedHashMap<Object, Object>() {{ put(T.label, \"person\"); put(\"name\", \"marko\"); }}).option(Merge.onMatch, new LinkedHashMap<Object, Object>() {{ put(T.label, new ArrayList<Object>() {{ add(\"manager\"); add(\"director\"); }}); }})",
+                "javascript": "g.mergeV(new Map([[T.label, \"person\"], [\"name\", \"marko\"]])).option(Merge.onMatch, new Map([[T.label, [\"manager\", \"director\"]]]))",
+                "python": "g.merge_v({ T.label: 'person', 'name': 'marko' }).option(Merge.on_match, { T.label: ['manager', 'director'] })"
+            },
+            {
+                "original": "g.V()",
+                "language": "g.V()",
+                "canonical": "g.V()",
+                "anonymized": "g.V()",
+                "dotnet": "g.V()",
+                "go": "g.V()",
+                "groovy": "g.V()",
+                "java": "g.V()",
+                "javascript": "g.V()",
+                "python": "g.V()"
+            },
+            {
+                "original": "g.V().hasLabel(\"manager\").hasLabel(\"director\")",
+                "language": "g.V().hasLabel(\"manager\").hasLabel(\"director\")",
+                "canonical": "g.V().hasLabel(\"manager\").hasLabel(\"director\")",
+                "anonymized": "g.V().hasLabel(string0).hasLabel(string1)",
+                "dotnet": "g.V().HasLabel(\"manager\").HasLabel(\"director\")",
+                "go": "g.V().HasLabel(\"manager\").HasLabel(\"director\")",
+                "groovy": "g.V().hasLabel(\"manager\").hasLabel(\"director\")",
+                "java": "g.V().hasLabel(\"manager\").hasLabel(\"director\")",
+                "javascript": "g.V().hasLabel(\"manager\").hasLabel(\"director\")",
+                "python": "g.V().has_label('manager').has_label('director')"
+            },
+            {
+                "original": "g.V().hasLabel(\"person\")",
+                "language": "g.V().hasLabel(\"person\")",
+                "canonical": "g.V().hasLabel(\"person\")",
+                "anonymized": "g.V().hasLabel(string0)",
+                "dotnet": "g.V().HasLabel(\"person\")",
+                "go": "g.V().HasLabel(\"person\")",
+                "groovy": "g.V().hasLabel(\"person\")",
+                "java": "g.V().hasLabel(\"person\")",
+                "javascript": "g.V().hasLabel(\"person\")",
+                "python": "g.V().has_label('person')"
+            }
+        ]
+    },
+    {
+        "scenario": "g_mergeVXlabel_person_name_markoX_optionXonMatch_label_emptyX",
+        "traversals": [
+            {
+                "original": "g.addV(\"person\").property(\"name\", \"marko\")",
+                "language": "g.addV(\"person\").property(\"name\", \"marko\")",
+                "canonical": "g.addV(\"person\").property(\"name\", \"marko\")",
+                "anonymized": "g.addV(string0).property(string1, string2)",
+                "dotnet": "g.AddV((string) \"person\").Property(\"name\", \"marko\")",
+                "go": "g.AddV(\"person\").Property(\"name\", \"marko\")",
+                "groovy": "g.addV(\"person\").property(\"name\", \"marko\")",
+                "java": "g.addV(\"person\").property(\"name\", \"marko\")",
+                "javascript": "g.addV(\"person\").property(\"name\", \"marko\")",
+                "python": "g.add_v('person').property('name', 'marko')"
+            },
+            {
+                "original": "g.mergeV([(T.label): \"person\", name: \"marko\"]).option(Merge.onMatch, [(T.label): []])",
+                "language": "g.mergeV([(T.label):\"person\", name:\"marko\"]).option(Merge.onMatch, [(T.label):[]])",
+                "canonical": "g.mergeV([(T.label):\"person\", name:\"marko\"]).option(Merge.onMatch, [(T.label):[]])",
+                "anonymized": "g.mergeV(map0).option(Merge.onMatch, map1)",
+                "dotnet": "g.MergeV((IDictionary<object, object>) new Dictionary<object, object> {{ T.Label, \"person\" }, { \"name\", \"marko\" }}).Option(Merge.OnMatch, (IDictionary<object, object>) new Dictionary<object, object> {{ T.Label, new List<object> {  } }})",
+                "go": "g.MergeV(map[interface{}]interface{}{gremlingo.T.Label: \"person\", \"name\": \"marko\" }).Option(gremlingo.Merge.OnMatch, map[interface{}]interface{}{gremlingo.T.Label: []interface{}{} })",
+                "groovy": "g.mergeV([(T.label):\"person\", name:\"marko\"]).option(Merge.onMatch, [(T.label):[]])",
+                "java": "g.mergeV(new LinkedHashMap<Object, Object>() {{ put(T.label, \"person\"); put(\"name\", \"marko\"); }}).option(Merge.onMatch, new LinkedHashMap<Object, Object>() {{ put(T.label, new ArrayList<Object>() {{  }}); }})",
+                "javascript": "g.mergeV(new Map([[T.label, \"person\"], [\"name\", \"marko\"]])).option(Merge.onMatch, new Map([[T.label, []]]))",
+                "python": "g.merge_v({ T.label: 'person', 'name': 'marko' }).option(Merge.on_match, { T.label: [] })"
+            },
+            {
+                "original": "g.V()",
+                "language": "g.V()",
+                "canonical": "g.V()",
+                "anonymized": "g.V()",
+                "dotnet": "g.V()",
+                "go": "g.V()",
+                "groovy": "g.V()",
+                "java": "g.V()",
+                "javascript": "g.V()",
+                "python": "g.V()"
+            },
+            {
+                "original": "g.V().hasLabel(\"vertex\")",
+                "language": "g.V().hasLabel(\"vertex\")",
+                "canonical": "g.V().hasLabel(\"vertex\")",
+                "anonymized": "g.V().hasLabel(string0)",
+                "dotnet": "g.V().HasLabel(\"vertex\")",
+                "go": "g.V().HasLabel(\"vertex\")",
+                "groovy": "g.V().hasLabel(\"vertex\")",
+                "java": "g.V().hasLabel(\"vertex\")",
+                "javascript": "g.V().hasLabel(\"vertex\")",
+                "python": "g.V().has_label('vertex')"
+            },
+            {
+                "original": "g.V().hasLabel(\"person\")",
+                "language": "g.V().hasLabel(\"person\")",
+                "canonical": "g.V().hasLabel(\"person\")",
+                "anonymized": "g.V().hasLabel(string0)",
+                "dotnet": "g.V().HasLabel(\"person\")",
+                "go": "g.V().HasLabel(\"person\")",
+                "groovy": "g.V().hasLabel(\"person\")",
+                "java": "g.V().hasLabel(\"person\")",
+                "javascript": "g.V().hasLabel(\"person\")",
+                "python": "g.V().has_label('person')"
+            }
+        ]
+    },
     {
         "scenario": "g_V_age_min",
         "traversals": [
@@ -40806,6 +41445,105 @@
             }
         ]
     },
+    {
+        "scenario": "g_V_hasLabelXpersonX_hasXname_markoX_addLabelXemployeeX_labels",
+        "traversals": [
+            {
+                "original": "g.addV(\"person\").property(\"name\", \"marko\")",
+                "language": "g.addV(\"person\").property(\"name\", \"marko\")",
+                "canonical": "g.addV(\"person\").property(\"name\", \"marko\")",
+                "anonymized": "g.addV(string0).property(string1, string2)",
+                "dotnet": "g.AddV((string) \"person\").Property(\"name\", \"marko\")",
+                "go": "g.AddV(\"person\").Property(\"name\", \"marko\")",
+                "groovy": "g.addV(\"person\").property(\"name\", \"marko\")",
+                "java": "g.addV(\"person\").property(\"name\", \"marko\")",
+                "javascript": "g.addV(\"person\").property(\"name\", \"marko\")",
+                "python": "g.add_v('person').property('name', 'marko')"
+            },
+            {
+                "original": "g.V().hasLabel(\"person\").has(\"name\", \"marko\").addLabel(\"employee\").labels().fold()",
+                "language": "g.V().hasLabel(\"person\").has(\"name\", \"marko\").addLabel(\"employee\").labels().fold()",
+                "canonical": "g.V().hasLabel(\"person\").has(\"name\", \"marko\").addLabel(\"employee\").labels().fold()",
+                "anonymized": "g.V().hasLabel(string0).has(string1, string2).addLabel(string3).labels().fold()",
+                "dotnet": "g.V().HasLabel(\"person\").Has(\"name\", \"marko\").AddLabel(\"employee\").Labels().Fold()",
+                "go": "g.V().HasLabel(\"person\").Has(\"name\", \"marko\").AddLabel(\"employee\").Labels().Fold()",
+                "groovy": "g.V().hasLabel(\"person\").has(\"name\", \"marko\").addLabel(\"employee\").labels().fold()",
+                "java": "g.V().hasLabel(\"person\").has(\"name\", \"marko\").addLabel(\"employee\").labels().fold()",
+                "javascript": "g.V().hasLabel(\"person\").has(\"name\", \"marko\").addLabel(\"employee\").labels().fold()",
+                "python": "g.V().has_label('person').has('name', 'marko').add_label('employee').labels().fold()"
+            },
+            {
+                "original": "g.V().hasLabel(\"person\").hasLabel(\"employee\")",
+                "language": "g.V().hasLabel(\"person\").hasLabel(\"employee\")",
+                "canonical": "g.V().hasLabel(\"person\").hasLabel(\"employee\")",
+                "anonymized": "g.V().hasLabel(string0).hasLabel(string1)",
+                "dotnet": "g.V().HasLabel(\"person\").HasLabel(\"employee\")",
+                "go": "g.V().HasLabel(\"person\").HasLabel(\"employee\")",
+                "groovy": "g.V().hasLabel(\"person\").hasLabel(\"employee\")",
+                "java": "g.V().hasLabel(\"person\").hasLabel(\"employee\")",
+                "javascript": "g.V().hasLabel(\"person\").hasLabel(\"employee\")",
+                "python": "g.V().has_label('person').has_label('employee')"
+            }
+        ]
+    },
+    {
+        "scenario": "g_V_addLabelXa_bX_labels_count",
+        "traversals": [
+            {
+                "original": "g.addV(\"person\")",
+                "language": "g.addV(\"person\")",
+                "canonical": "g.addV(\"person\")",
+                "anonymized": "g.addV(string0)",
+                "dotnet": "g.AddV((string) \"person\")",
+                "go": "g.AddV(\"person\")",
+                "groovy": "g.addV(\"person\")",
+                "java": "g.addV(\"person\")",
+                "javascript": "g.addV(\"person\")",
+                "python": "g.add_v('person')"
+            },
+            {
+                "original": "g.V().addLabel(\"a\", \"b\").labels().count()",
+                "language": "g.V().addLabel(\"a\", \"b\").labels().count()",
+                "canonical": "g.V().addLabel(\"a\", \"b\").labels().count()",
+                "anonymized": "g.V().addLabel(string0, string1).labels().count()",
+                "dotnet": "g.V().AddLabel(\"a\", \"b\").Labels().Count()",
+                "go": "g.V().AddLabel(\"a\", \"b\").Labels().Count()",
+                "groovy": "g.V().addLabel(\"a\", \"b\").labels().count()",
+                "java": "g.V().addLabel(\"a\", \"b\").labels().count()",
+                "javascript": "g.V().addLabel(\"a\", \"b\").labels().count()",
+                "python": "g.V().add_label('a', 'b').labels().count()"
+            }
+        ]
+    },
+    {
+        "scenario": "g_V_addLabelXexistingX_labels_count",
+        "traversals": [
+            {
+                "original": "g.addV(\"person\")",
+                "language": "g.addV(\"person\")",
+                "canonical": "g.addV(\"person\")",
+                "anonymized": "g.addV(string0)",
+                "dotnet": "g.AddV((string) \"person\")",
+                "go": "g.AddV(\"person\")",
+                "groovy": "g.addV(\"person\")",
+                "java": "g.addV(\"person\")",
+                "javascript": "g.addV(\"person\")",
+                "python": "g.add_v('person')"
+            },
+            {
+                "original": "g.V().addLabel(\"person\").labels().count()",
+                "language": "g.V().addLabel(\"person\").labels().count()",
+                "canonical": "g.V().addLabel(\"person\").labels().count()",
+                "anonymized": "g.V().addLabel(string0).labels().count()",
+                "dotnet": "g.V().AddLabel(\"person\").Labels().Count()",
+                "go": "g.V().AddLabel(\"person\").Labels().Count()",
+                "groovy": "g.V().addLabel(\"person\").labels().count()",
+                "java": "g.V().addLabel(\"person\").labels().count()",
+                "javascript": "g.V().addLabel(\"person\").labels().count()",
+                "python": "g.V().add_label('person').labels().count()"
+            }
+        ]
+    },
     {
         "scenario": "g_V_valueXnameX_aggregateXxX_capXxX",
         "traversals": [
@@ -41775,6 +42513,146 @@
             }
         ]
     },
+    {
+        "scenario": "g_V_dropLabelXaX_labels",
+        "traversals": [
+            {
+                "original": "g.addV(\"a\", \"b\")",
+                "language": "g.addV(\"a\", \"b\")",
+                "canonical": "g.addV(\"a\", \"b\")",
+                "anonymized": "g.addV(string0, string1)",
+                "dotnet": "g.AddV((string) \"a\", (string) \"b\")",
+                "go": "g.AddV(\"a\", \"b\")",
+                "groovy": "g.addV(\"a\", \"b\")",
+                "java": "g.addV(\"a\", \"b\")",
+                "javascript": "g.addV(\"a\", \"b\")",
+                "python": "g.add_v('a', 'b')"
+            },
+            {
+                "original": "g.V().dropLabel(\"a\").labels().fold()",
+                "language": "g.V().dropLabel(\"a\").labels().fold()",
+                "canonical": "g.V().dropLabel(\"a\").labels().fold()",
+                "anonymized": "g.V().dropLabel(string0).labels().fold()",
+                "dotnet": "g.V().DropLabel(\"a\").Labels().Fold()",
+                "go": "g.V().DropLabel(\"a\").Labels().Fold()",
+                "groovy": "g.V().dropLabel(\"a\").labels().fold()",
+                "java": "g.V().dropLabel(\"a\").labels().fold()",
+                "javascript": "g.V().dropLabel(\"a\").labels().fold()",
+                "python": "g.V().drop_label('a').labels().fold()"
+            },
+            {
+                "original": "g.V().hasLabel(\"a\")",
+                "language": "g.V().hasLabel(\"a\")",
+                "canonical": "g.V().hasLabel(\"a\")",
+                "anonymized": "g.V().hasLabel(string0)",
+                "dotnet": "g.V().HasLabel(\"a\")",
+                "go": "g.V().HasLabel(\"a\")",
+                "groovy": "g.V().hasLabel(\"a\")",
+                "java": "g.V().hasLabel(\"a\")",
+                "javascript": "g.V().hasLabel(\"a\")",
+                "python": "g.V().has_label('a')"
+            },
+            {
+                "original": "g.V().hasLabel(\"b\")",
+                "language": "g.V().hasLabel(\"b\")",
+                "canonical": "g.V().hasLabel(\"b\")",
+                "anonymized": "g.V().hasLabel(string0)",
+                "dotnet": "g.V().HasLabel(\"b\")",
+                "go": "g.V().HasLabel(\"b\")",
+                "groovy": "g.V().hasLabel(\"b\")",
+                "java": "g.V().hasLabel(\"b\")",
+                "javascript": "g.V().hasLabel(\"b\")",
+                "python": "g.V().has_label('b')"
+            }
+        ]
+    },
+    {
+        "scenario": "g_V_dropLabels_labels",
+        "traversals": [
+            {
+                "original": "g.addV(\"a\", \"b\")",
+                "language": "g.addV(\"a\", \"b\")",
+                "canonical": "g.addV(\"a\", \"b\")",
+                "anonymized": "g.addV(string0, string1)",
+                "dotnet": "g.AddV((string) \"a\", (string) \"b\")",
+                "go": "g.AddV(\"a\", \"b\")",
+                "groovy": "g.addV(\"a\", \"b\")",
+                "java": "g.addV(\"a\", \"b\")",
+                "javascript": "g.addV(\"a\", \"b\")",
+                "python": "g.add_v('a', 'b')"
+            },
+            {
+                "original": "g.V().dropLabels().labels()",
+                "language": "g.V().dropLabels().labels()",
+                "canonical": "g.V().dropLabels().labels()",
+                "anonymized": "g.V().dropLabels().labels()",
+                "dotnet": "g.V().DropLabels().Labels()",
+                "go": "g.V().DropLabels().Labels()",
+                "groovy": "g.V().dropLabels().labels()",
+                "java": "g.V().dropLabels().labels()",
+                "javascript": "g.V().dropLabels().labels()",
+                "python": "g.V().drop_labels().labels()"
+            }
+        ]
+    },
+    {
+        "scenario": "g_V_dropLabelXa_bX_labels",
+        "traversals": [
+            {
+                "original": "g.addV(\"a\", \"b\", \"c\")",
+                "language": "g.addV(\"a\", \"b\", \"c\")",
+                "canonical": "g.addV(\"a\", \"b\", \"c\")",
+                "anonymized": "g.addV(string0, string1, string2)",
+                "dotnet": "g.AddV((string) \"a\", (string) \"b\", (string) \"c\")",
+                "go": "g.AddV(\"a\", \"b\", \"c\")",
+                "groovy": "g.addV(\"a\", \"b\", \"c\")",
+                "java": "g.addV(\"a\", \"b\", \"c\")",
+                "javascript": "g.addV(\"a\", \"b\", \"c\")",
+                "python": "g.add_v('a', 'b', 'c')"
+            },
+            {
+                "original": "g.V().dropLabel(\"a\", \"b\").labels()",
+                "language": "g.V().dropLabel(\"a\", \"b\").labels()",
+                "canonical": "g.V().dropLabel(\"a\", \"b\").labels()",
+                "anonymized": "g.V().dropLabel(string0, string1).labels()",
+                "dotnet": "g.V().DropLabel(\"a\", \"b\").Labels()",
+                "go": "g.V().DropLabel(\"a\", \"b\").Labels()",
+                "groovy": "g.V().dropLabel(\"a\", \"b\").labels()",
+                "java": "g.V().dropLabel(\"a\", \"b\").labels()",
+                "javascript": "g.V().dropLabel(\"a\", \"b\").labels()",
+                "python": "g.V().drop_label('a', 'b').labels()"
+            }
+        ]
+    },
+    {
+        "scenario": "g_V_dropLabels_defaultLabel",
+        "traversals": [
+            {
+                "original": "g.addV(\"person\")",
+                "language": "g.addV(\"person\")",
+                "canonical": "g.addV(\"person\")",
+                "anonymized": "g.addV(string0)",
+                "dotnet": "g.AddV((string) \"person\")",
+                "go": "g.AddV(\"person\")",
+                "groovy": "g.addV(\"person\")",
+                "java": "g.addV(\"person\")",
+                "javascript": "g.addV(\"person\")",
+                "python": "g.add_v('person')"
+            },
+            {
+                "original": "g.V().dropLabels().labels()",
+                "language": "g.V().dropLabels().labels()",
+                "canonical": "g.V().dropLabels().labels()",
+                "anonymized": "g.V().dropLabels().labels()",
+                "dotnet": "g.V().DropLabels().Labels()",
+                "go": "g.V().DropLabels().Labels()",
+                "groovy": "g.V().dropLabels().labels()",
+                "java": "g.V().dropLabels().labels()",
+                "javascript": "g.V().dropLabels().labels()",
+                "python": "g.V().drop_labels().labels()"
+            }
+        ]
+    },
     {
         "scenario": "g_V_fail",
         "traversals": [
diff --git a/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerTransactionGraph.java b/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerTransactionGraph.java
index 3e6931a1d8..e6673e4be6 100644
--- a/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerTransactionGraph.java
+++ b/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerTransactionGraph.java
@@ -137,7 +137,8 @@ public final class TinkerTransactionGraph extends AbstractTinkerGraph {
         Object idValue = vertexIdManager.convert(ElementHelper.getIdValue(keyValues).orElse(null));
         if (null == idValue)
             idValue = vertexIdManager.getNextId(this);
-        final String label = ElementHelper.getLabelValue(keyValues).orElse(Vertex.DEFAULT_LABEL);
+        final Set<String> labels = ElementHelper.getLabelsValue(keyValues).orElse(
+                Collections.singleton(Vertex.DEFAULT_LABEL));
 
         this.tx().readWrite();
         final long txNumber = transaction.getTxNumber();
@@ -162,7 +163,7 @@ public final class TinkerTransactionGraph extends AbstractTinkerGraph {
         if (container == null)
             container = newContainer;
 
-        final TinkerVertex vertex = new TinkerVertex(idValue, label, this, version);
+        final TinkerVertex vertex = new TinkerVertex(idValue, labels, this, version);
         ElementHelper.attachProperties(vertex, VertexProperty.Cardinality.list, keyValues);
         container.setDraft(vertex, (TinkerTransaction) tx());
 
diff --git a/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerVertex.java b/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerVertex.java
index 1c7c52802f..67c5ad4692 100644
--- a/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerVertex.java
+++ b/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerVertex.java
@@ -94,6 +94,22 @@ public class TinkerVertex extends TinkerElement implements Vertex {
         }
     }
 
+    /**
+     * Constructs a TinkerVertex with multiple labels and a specific version (for transactional graphs).
+     */
+    protected TinkerVertex(final Object id, final Set<String> labels, final AbstractTinkerGraph graph, final long currentVersion) {
+        super(id, (labels == null || labels.isEmpty()) ? Vertex.DEFAULT_LABEL : labels.iterator().next(), currentVersion);
+        this.graph = graph;
+        this.isTxMode = graph instanceof TinkerTransactionGraph;
+        this.allowNullPropertyValues = graph.features().vertex().supportsNullPropertyValues();
+        if (labels == null || labels.isEmpty()) {
+            this.vertexLabels = new LinkedHashSet<>();
+            this.vertexLabels.add(Vertex.DEFAULT_LABEL);
+        } else {
+            this.vertexLabels = new LinkedHashSet<>(labels);
+        }
+    }
+
     @Override
     public Set<String> labels() {
         return Collections.unmodifiableSet(this.vertexLabels);


(tinkerpop) 05/06: implement edge multi-label

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

xiazcy pushed a commit to branch multi-label-experiment
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git

commit ebae85332201eec72e3e6ec42b6c96a22b23311d
Author: Yang Xia <xi...@gmail.com>
AuthorDate: Fri Jun 5 14:45:39 2026 -0700

    implement edge multi-label
---
 AGENTS.md                                          |  31 ++++++
 .../grammar/DefaultGremlinBaseVisitor.java         |   8 ++
 .../language/grammar/TraversalMethodVisitor.java   |  28 +++++
 .../grammar/TraversalSourceSpawnMethodVisitor.java |  27 +++--
 .../traversal/dsl/graph/GraphTraversal.java        |  35 +++++--
 .../traversal/dsl/graph/GraphTraversalSource.java  |  52 ++++++++--
 .../gremlin/process/traversal/dsl/graph/__.java    |   7 ++
 .../step/map/AbstractAddEdgeStepPlaceholder.java   |   5 +
 .../map/AbstractAddElementStepPlaceholder.java     |   7 +-
 .../step/map/AbstractAddVertexStepPlaceholder.java |   6 ++
 .../traversal/step/map/AddEdgeStartStep.java       |  32 +++++-
 .../step/map/AddEdgeStartStepPlaceholder.java      |  10 +-
 .../process/traversal/step/map/AddEdgeStep.java    |  32 +++++-
 .../traversal/step/map/AddEdgeStepPlaceholder.java |  10 +-
 .../traversal/step/map/AddVertexStartStep.java     |  11 ++
 .../step/map/AddVertexStartStepPlaceholder.java    |  10 +-
 .../process/traversal/step/map/AddVertexStep.java  |  11 ++
 .../step/map/AddVertexStepPlaceholder.java         |  10 +-
 .../process/traversal/step/map/ElementMapStep.java |   6 +-
 .../process/traversal/step/map/MergeEdgeStep.java  | 113 ++++++++++++++++++---
 .../traversal/step/map/PropertyMapStep.java        |   6 +-
 .../traversal/step/sideEffect/AddLabelStep.java    |  18 ++--
 .../traversal/step/sideEffect/DropLabelsStep.java  |  18 ++--
 .../process/traversal/step/util/WithOptions.java   |  18 ++++
 .../process/traversal/step/util/event/Event.java   |  26 +++++
 .../traversal/step/util/event/EventUtil.java       |  20 ++++
 .../structure/io/binary/types/EdgeSerializer.java  |  63 +++++++++---
 .../io/graphson/GraphSONSerializersV4.java         |  12 ++-
 .../structure/util/detached/DetachedEdge.java      |  34 +++++++
 .../structure/util/reference/ReferenceEdge.java    |  31 ++++++
 .../gremlin/structure/util/star/StarGraph.java     |  63 +++++++++++-
 gremlin-language/src/main/antlr4/Gremlin.g4        |   8 +-
 .../tinkergraph/structure/AbstractTinkerGraph.java |  20 ++++
 .../gremlin/tinkergraph/structure/TinkerEdge.java  |  89 +++++++++++++++-
 .../tinkergraph/structure/TinkerElement.java       |   2 +-
 .../gremlin/tinkergraph/structure/TinkerGraph.java |  30 ++++++
 .../structure/TinkerTransactionGraph.java          |  34 +++++++
 .../tinkergraph/structure/TinkerVertex.java        |  43 ++------
 .../step/sideEffect/LabelMutationStepTest.java     |  16 +--
 .../structure/TinkerVertexMultiLabelTest.java      |  12 ++-
 40 files changed, 877 insertions(+), 137 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index 9695bfbf86..f1826478d2 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -71,3 +71,34 @@ These rules apply to any AI/IDE assistant operating on this repository.
 
 1. Prefer no change over an unsafe or speculative change.
 2. Ask for clarification.
+
+## Beads Issue Tracker
+
+This project uses **bd (beads)** for issue tracking. Run `bd prime` to see full workflow context and commands.
+
+### Quick Reference
+
+```bash
+bd ready              # Find available work
+bd show <id>          # View issue details
+bd update <id> --claim  # Claim work
+bd close <id>         # Complete work
+```
+
+### Rules
+
+- Use `bd` for ALL task tracking — do NOT use TodoWrite, TaskCreate, or markdown TODO lists
+- Run `bd prime` for detailed command reference and session close protocol
+- Use `bd remember` for persistent knowledge — do NOT use MEMORY.md files
+
+**Architecture in one line:** issues live in a local Dolt DB; sync uses `refs/dolt/data` on your git remote; `.beads/issues.jsonl` is a passive export. See https://github.com/gastownhall/beads/blob/main/docs/SYNC_CONCEPTS.md for details and anti-patterns.
+
+## Session Completion
+
+**When ending a work session**, you MUST complete ALL steps below.
+
+**MANDATORY WORKFLOW:**
+
+1. **File issues for remaining work** - Create issues for anything that needs follow-up
+2. **Run quality gates** (if code changed) - Tests, linters, builds
+3. **Update issue status** - Close finished work, update in-progress items
\ No newline at end of file
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/DefaultGremlinBaseVisitor.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/DefaultGremlinBaseVisitor.java
index 6a8cb92d8d..5257be977a 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/DefaultGremlinBaseVisitor.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/DefaultGremlinBaseVisitor.java
@@ -167,6 +167,14 @@ public class DefaultGremlinBaseVisitor<T> extends AbstractParseTreeVisitor<T> im
 	 * {@inheritDoc}
 	 */
 	@Override public T visitTraversalMethod_addE_String(final GremlinParser.TraversalMethod_addE_StringContext ctx) { notImplemented(ctx); return null; }
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override public T visitTraversalMethod_addE_StringVarargs(final GremlinParser.TraversalMethod_addE_StringVarargsContext ctx) { notImplemented(ctx); return null; }
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override public T visitTraversalMethod_addE_Empty(final GremlinParser.TraversalMethod_addE_EmptyContext ctx) { notImplemented(ctx); return null; }
 	/**
 	 * {@inheritDoc}
 	 */
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalMethodVisitor.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalMethodVisitor.java
index b12a20111d..cc65794ed6 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalMethodVisitor.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalMethodVisitor.java
@@ -30,6 +30,7 @@ import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
 import org.apache.tinkerpop.gremlin.process.traversal.step.GValue;
 import org.apache.tinkerpop.gremlin.structure.Column;
 import org.apache.tinkerpop.gremlin.structure.Direction;
+import org.apache.tinkerpop.gremlin.structure.Edge;
 import org.apache.tinkerpop.gremlin.structure.T;
 import org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality;
 
@@ -204,6 +205,33 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
         }
     }
 
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public GraphTraversal visitTraversalMethod_addE_StringVarargs(final GremlinParser.TraversalMethod_addE_StringVarargsContext ctx) {
+        final List<GremlinParser.StringArgumentContext> args = ctx.stringArgument();
+        final Object firstLiteralOrVar = antlr.argumentVisitor.visitStringArgument(args.get(0));
+        final String firstLabel = firstLiteralOrVar instanceof String ? (String) firstLiteralOrVar : ((GValue<String>) firstLiteralOrVar).get();
+        final Object secondLiteralOrVar = antlr.argumentVisitor.visitStringArgument(args.get(1));
+        final String secondLabel = secondLiteralOrVar instanceof String ? (String) secondLiteralOrVar : ((GValue<String>) secondLiteralOrVar).get();
+
+        final String[] moreLabels = new String[args.size() - 2];
+        for (int i = 2; i < args.size(); i++) {
+            final Object literalOrVar = antlr.argumentVisitor.visitStringArgument(args.get(i));
+            moreLabels[i - 2] = literalOrVar instanceof String ? (String) literalOrVar : ((GValue<String>) literalOrVar).get();
+        }
+        return this.graphTraversal.addE(firstLabel, secondLabel, moreLabels);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public GraphTraversal visitTraversalMethod_addE_Empty(final GremlinParser.TraversalMethod_addE_EmptyContext ctx) {
+        return this.graphTraversal.addE(Edge.DEFAULT_LABEL);
+    }
+
     /**
      * {@inheritDoc}
      */
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalSourceSpawnMethodVisitor.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalSourceSpawnMethodVisitor.java
index c2ca344c99..5ce9b41c09 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalSourceSpawnMethodVisitor.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalSourceSpawnMethodVisitor.java
@@ -57,17 +57,32 @@ public class TraversalSourceSpawnMethodVisitor extends DefaultGremlinBaseVisitor
      */
     @Override
     public GraphTraversal visitTraversalSourceSpawnMethod_addE(final GremlinParser.TraversalSourceSpawnMethod_addEContext ctx) {
-        if (ctx.stringArgument() != null) {
-            final Object literalOrVar = antlr.argumentVisitor.visitStringArgument(ctx.stringArgument());
-            if (GValue.valueInstanceOf(literalOrVar, String.class)) {
-                return this.traversalSource.addE((GValue<String>) literalOrVar);
+        final List<GremlinParser.StringArgumentContext> stringArgs = ctx.stringArgument();
+        if (stringArgs != null && !stringArgs.isEmpty()) {
+            if (stringArgs.size() == 1) {
+                final Object literalOrVar = antlr.argumentVisitor.visitStringArgument(stringArgs.get(0));
+                if (GValue.valueInstanceOf(literalOrVar, String.class)) {
+                    return this.traversalSource.addE((GValue<String>) literalOrVar);
+                } else {
+                    return this.traversalSource.addE((String) literalOrVar);
+                }
             } else {
-                return this.traversalSource.addE((String) literalOrVar);
+                // Multi-label: addE("a", "b", ...)
+                final Object firstLiteralOrVar = antlr.argumentVisitor.visitStringArgument(stringArgs.get(0));
+                final String firstLabel = firstLiteralOrVar instanceof String ? (String) firstLiteralOrVar : ((GValue<String>) firstLiteralOrVar).get();
+                final Object secondLiteralOrVar = antlr.argumentVisitor.visitStringArgument(stringArgs.get(1));
+                final String secondLabel = secondLiteralOrVar instanceof String ? (String) secondLiteralOrVar : ((GValue<String>) secondLiteralOrVar).get();
+                final String[] moreLabels = new String[stringArgs.size() - 2];
+                for (int i = 2; i < stringArgs.size(); i++) {
+                    final Object literalOrVar = antlr.argumentVisitor.visitStringArgument(stringArgs.get(i));
+                    moreLabels[i - 2] = literalOrVar instanceof String ? (String) literalOrVar : ((GValue<String>) literalOrVar).get();
+                }
+                return this.traversalSource.addE(firstLabel, secondLabel, moreLabels);
             }
         } else if (ctx.nestedTraversal() != null) {
             return this.traversalSource.addE(anonymousVisitor.visitNestedTraversal(ctx.nestedTraversal()));
         } else {
-            throw new IllegalArgumentException("addE with empty arguments is not valid.");
+            return this.traversalSource.addE();
         }
     }
 
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.java
index 31c9874af5..126c48ce73 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.java
@@ -234,6 +234,7 @@ import java.util.Comparator;
 import java.util.Date;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -1464,12 +1465,11 @@ public interface GraphTraversal<S, E> extends Traversal<S, E> {
             if (null == l) throw new IllegalArgumentException("vertexLabel cannot be null");
         }
         this.asAdmin().getGremlinLang().addStep(Symbols.addV, label1, label2, moreLabels);
-        this.asAdmin().addStep(new AddVertexStepPlaceholder<>(this.asAdmin(), label1));
-        // Add the AddLabelStep directly to avoid double-recording in GremlinLang.
-        // The addV step above already recorded all labels; calling t.addLabel() would
-        // record an additional addLabel() step in GremlinLang, producing incorrect output
-        // like g.addV("a","b").addLabel("b") instead of g.addV("a","b").
-        return this.asAdmin().addStep(new AddLabelStep<>(this.asAdmin(), label2, moreLabels));
+        final Set<String> allLabels = new LinkedHashSet<>();
+        allLabels.add(label1);
+        allLabels.add(label2);
+        Collections.addAll(allLabels, moreLabels);
+        return this.asAdmin().addStep(new AddVertexStepPlaceholder<>(this.asAdmin(), allLabels));
     }
 
     /**
@@ -1629,6 +1629,29 @@ public interface GraphTraversal<S, E> extends Traversal<S, E> {
         return this.asAdmin().addStep(step);
     }
 
+    /**
+     * Multi-label edge creation.
+     *
+     * @param label1     the first label
+     * @param label2     the second label
+     * @param moreLabels additional labels
+     * @return the traversal with the {@link AddEdgeStepContract} added
+     * @since 4.0.0
+     */
+    public default GraphTraversal<S, Edge> addE(final String label1, final String label2, final String... moreLabels) {
+        if (null == label1) throw new IllegalArgumentException("edgeLabel cannot be null");
+        if (null == label2) throw new IllegalArgumentException("edgeLabel cannot be null");
+        for (final String l : moreLabels) {
+            if (null == l) throw new IllegalArgumentException("edgeLabel cannot be null");
+        }
+        this.asAdmin().getGremlinLang().addStep(Symbols.addE, label1, label2, moreLabels);
+        final Set<String> allLabels = new LinkedHashSet<>();
+        allLabels.add(label1);
+        allLabels.add(label2);
+        Collections.addAll(allLabels, moreLabels);
+        return this.asAdmin().addStep(new AddEdgeStepPlaceholder<>(this.asAdmin(), allLabels));
+    }
+
     /**
      * Provide {@code from()}-modulation to respective steps.
      *
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversalSource.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversalSource.java
index 8777de2d14..288841e8ee 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversalSource.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversalSource.java
@@ -31,7 +31,6 @@ import org.apache.tinkerpop.gremlin.process.traversal.step.GValue;
 import org.apache.tinkerpop.gremlin.process.traversal.step.branch.UnionStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.AddEdgeStartStepPlaceholder;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.AddVertexStartStepPlaceholder;
-import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.AddLabelStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.CallStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.CallStepPlaceholder;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.GraphStep;
@@ -53,9 +52,12 @@ import org.apache.tinkerpop.gremlin.structure.util.StringFactory;
 import org.apache.tinkerpop.gremlin.structure.util.empty.EmptyGraph;
 
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Optional;
+import java.util.Set;
 import java.util.function.BinaryOperator;
 import java.util.function.Supplier;
 import java.util.function.UnaryOperator;
@@ -383,12 +385,11 @@ public class GraphTraversalSource implements TraversalSource {
         final GraphTraversalSource clone = this.clone();
         clone.gremlinLang.addStep(GraphTraversal.Symbols.addV, label1, label2, moreLabels);
         final GraphTraversal.Admin<Vertex, Vertex> traversal = new DefaultGraphTraversal<>(clone);
-        traversal.addStep(new AddVertexStartStepPlaceholder(traversal, label1));
-        // Add the AddLabelStep directly to avoid double-recording in GremlinLang.
-        // The addV step above already recorded all labels; calling t.addLabel() would
-        // record an additional addLabel() step in GremlinLang, producing incorrect output
-        // like g.addV("a","b").addLabel("b") instead of g.addV("a","b").
-        return traversal.addStep(new AddLabelStep<>(traversal, label2, moreLabels));
+        final Set<String> allLabels = new LinkedHashSet<>();
+        allLabels.add(label1);
+        allLabels.add(label2);
+        Collections.addAll(allLabels, moreLabels);
+        return traversal.addStep(new AddVertexStartStepPlaceholder(traversal, allLabels));
     }
 
     /**
@@ -427,6 +428,43 @@ public class GraphTraversalSource implements TraversalSource {
         return traversal.addStep(new AddEdgeStartStepPlaceholder(traversal, label));
     }
 
+    /**
+     * Spawns a {@link GraphTraversal} by adding an edge with multiple labels.
+     *
+     * @param label1     the first label
+     * @param label2     the second label
+     * @param moreLabels additional labels
+     * @return the traversal with the edge added
+     * @since 4.0.0
+     */
+    public GraphTraversal<Edge, Edge> addE(final String label1, final String label2, final String... moreLabels) {
+        if (null == label1) throw new IllegalArgumentException("edgeLabel cannot be null");
+        if (null == label2) throw new IllegalArgumentException("edgeLabel cannot be null");
+        for (final String l : moreLabels) {
+            if (null == l) throw new IllegalArgumentException("edgeLabel cannot be null");
+        }
+        final GraphTraversalSource clone = this.clone();
+        clone.gremlinLang.addStep(GraphTraversal.Symbols.addE, label1, label2, moreLabels);
+        final GraphTraversal.Admin<Edge, Edge> traversal = new DefaultGraphTraversal<>(clone);
+        final Set<String> allLabels = new LinkedHashSet<>();
+        allLabels.add(label1);
+        allLabels.add(label2);
+        Collections.addAll(allLabels, moreLabels);
+        return traversal.addStep(new AddEdgeStartStepPlaceholder(traversal, allLabels));
+    }
+
+    /**
+     * Spawns a {@link GraphTraversal} by adding an edge with the provider's default label.
+     *
+     * @since 4.0.0
+     */
+    public GraphTraversal<Edge, Edge> addE() {
+        final GraphTraversalSource clone = this.clone();
+        clone.gremlinLang.addStep(GraphTraversal.Symbols.addE);
+        final GraphTraversal.Admin<Edge, Edge> traversal = new DefaultGraphTraversal<>(clone);
+        return traversal.addStep(new AddEdgeStartStepPlaceholder(traversal, (String) null));
+    }
+
     /**
      * Spawns a {@link GraphTraversal} by doing a merge (i.e. upsert) style operation for an {@link Vertex} using a
      * {@code Map} as an argument. The {@code Map} represents search criteria and will match each of the supplied
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/__.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/__.java
index a9ad25b924..8324ca6095 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/__.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/__.java
@@ -738,6 +738,13 @@ public class __ {
         return __.<A>start().addE(edgeLabel);
     }
 
+    /**
+     * @see GraphTraversal#addE(String, String, String...)
+     */
+    public static <A> GraphTraversal<A, Edge> addE(final String label1, final String label2, final String... moreLabels) {
+        return __.<A>start().addE(label1, label2, moreLabels);
+    }
+
     /**
      * @see GraphTraversal#addE(GValue)
      */
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AbstractAddEdgeStepPlaceholder.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AbstractAddEdgeStepPlaceholder.java
index fb1ce7e8c9..95d377c317 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AbstractAddEdgeStepPlaceholder.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AbstractAddEdgeStepPlaceholder.java
@@ -29,6 +29,7 @@ import org.apache.tinkerpop.gremlin.structure.util.reference.ReferenceVertex;
 import java.util.Collection;
 import java.util.List;
 import java.util.Objects;
+import java.util.Set;
 
 public abstract class AbstractAddEdgeStepPlaceholder<S> extends AbstractAddElementStepPlaceholder<S, Edge, Event.EdgeAddedEvent> implements AddEdgeStepContract<S> {
     protected Traversal.Admin<?, ?> from;
@@ -42,6 +43,10 @@ public abstract class AbstractAddEdgeStepPlaceholder<S> extends AbstractAddEleme
         super(traversal, label);
     }
 
+    public AbstractAddEdgeStepPlaceholder(Traversal.Admin traversal, Set<String> labels) {
+        super(traversal, labels);
+    }
+
     public AbstractAddEdgeStepPlaceholder(Traversal.Admin traversal, Traversal.Admin<S, String> labelTraversal) {
         super(traversal, labelTraversal);
     }
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AbstractAddElementStepPlaceholder.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AbstractAddElementStepPlaceholder.java
index 830fef2c80..a2015b4613 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AbstractAddElementStepPlaceholder.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AbstractAddElementStepPlaceholder.java
@@ -61,7 +61,7 @@ public abstract class AbstractAddElementStepPlaceholder<S, E extends Element, X
     protected AbstractAddElementStepPlaceholder(final Traversal.Admin traversal, final GValue<String> label) {
         super(traversal);
         this.label = label == null ? this.getDefaultLabel() : label;
-        if (label.isVariable()) {
+        if (label != null && label.isVariable()) {
             traversal.getGValueManager().register(label);
         }
     }
@@ -75,6 +75,11 @@ public abstract class AbstractAddElementStepPlaceholder<S, E extends Element, X
         addTraversal(labelTraversal);
     }
 
+    protected AbstractAddElementStepPlaceholder(final Traversal.Admin traversal, final Set<String> labels) {
+        super(traversal);
+        this.label = (labels == null || labels.isEmpty()) ? this.getDefaultLabel() : labels;
+    }
+
     protected abstract String getDefaultLabel();
 
     @Override
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AbstractAddVertexStepPlaceholder.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AbstractAddVertexStepPlaceholder.java
index 66aa3df116..3e0f0c1c0f 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AbstractAddVertexStepPlaceholder.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AbstractAddVertexStepPlaceholder.java
@@ -25,6 +25,7 @@ import org.apache.tinkerpop.gremlin.process.traversal.step.util.event.Event;
 import org.apache.tinkerpop.gremlin.structure.Vertex;
 
 import java.util.Objects;
+import java.util.Set;
 
 public abstract class AbstractAddVertexStepPlaceholder<S> extends AbstractAddElementStepPlaceholder<S, Vertex, Event.VertexAddedEvent>
         implements AddVertexStepContract<S>, GValueHolder<S, Vertex> {
@@ -46,6 +47,11 @@ public abstract class AbstractAddVertexStepPlaceholder<S> extends AbstractAddEle
         userProvidedLabel = vertexLabelTraversal != null;
     }
 
+    protected AbstractAddVertexStepPlaceholder(final Traversal.Admin traversal, final Set<String> labels) {
+        super(traversal, labels);
+        userProvidedLabel = labels != null && !labels.isEmpty();
+    }
+
     @Override
     protected String getDefaultLabel() {
         return Vertex.DEFAULT_LABEL;
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddEdgeStartStep.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddEdgeStartStep.java
index 628587a509..99ccd7ce9e 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddEdgeStartStep.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddEdgeStartStep.java
@@ -19,7 +19,10 @@
 
 package org.apache.tinkerpop.gremlin.process.traversal.step.map;
 
+import java.util.Arrays;
 import java.util.Collections;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -67,6 +70,15 @@ public class AddEdgeStartStep extends AbstractStep<Edge, Edge> implements AddEdg
         this.internalParameters.set(this, T.label, edgeLabelTraversal);
     }
 
+    public AddEdgeStartStep(final Traversal.Admin traversal, final Set<String> labels) {
+        super(traversal);
+        if (labels == null || labels.isEmpty()) {
+            this.internalParameters.set(this, T.label, Edge.DEFAULT_LABEL);
+        } else {
+            this.internalParameters.set(this, T.label, labels);
+        }
+    }
+
     @Override
     public <S, E> List<Traversal.Admin<S, E>> getLocalChildren() {
         return this.internalParameters.getTraversals();
@@ -121,7 +133,21 @@ public class AddEdgeStartStep extends AbstractStep<Edge, Edge> implements AddEdg
             // a dead traverser to trigger the traversal
             final Traverser.Admin traverser = generator.generate(1, (Step) this, 1);
 
-            final String edgeLabel = (String) this.internalParameters.get(traverser, T.label, () -> Edge.DEFAULT_LABEL).get(0);
+            final Object labelParam = this.internalParameters.get(traverser, T.label, () -> Edge.DEFAULT_LABEL).get(0);
+            final String edgeLabel;
+            final Set<String> additionalLabels;
+            if (labelParam instanceof Set) {
+                final Set<String> labelSet = (Set<String>) labelParam;
+                final Iterator<String> iter = labelSet.iterator();
+                edgeLabel = iter.next();
+                additionalLabels = new LinkedHashSet<>();
+                while (iter.hasNext()) {
+                    additionalLabels.add(iter.next());
+                }
+            } else {
+                edgeLabel = (String) labelParam;
+                additionalLabels = Collections.emptySet();
+            }
 
             // FROM/TO must be set and must be vertices
             Object theTo = this.internalParameters.get(traverser, TO, () -> null).get(0);
@@ -165,6 +191,10 @@ public class AddEdgeStartStep extends AbstractStep<Edge, Edge> implements AddEdg
             }
 
             final Edge edge = fromVertex.addEdge(edgeLabel, toVertex, this.internalParameters.getKeyValues(traverser, TO, FROM, T.label));
+            if (!additionalLabels.isEmpty()) {
+                final String[] extra = additionalLabels.toArray(new String[0]);
+                edge.addLabel(extra[0], Arrays.copyOfRange(extra, 1, extra.length));
+            }
             EventUtil.registerEdgeCreation(callbackRegistry, getTraversal(), edge);
             return generator.generate(edge, this, 1L);
         } else
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddEdgeStartStepPlaceholder.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddEdgeStartStepPlaceholder.java
index 6042823e17..bbf4d429f3 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddEdgeStartStepPlaceholder.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddEdgeStartStepPlaceholder.java
@@ -24,6 +24,8 @@ import org.apache.tinkerpop.gremlin.process.traversal.lambda.GValueConstantTrave
 import org.apache.tinkerpop.gremlin.process.traversal.step.GValue;
 import org.apache.tinkerpop.gremlin.structure.Edge;
 
+import java.util.Set;
+
 public class AddEdgeStartStepPlaceholder extends AbstractAddEdgeStepPlaceholder<Edge> {
 
     public AddEdgeStartStepPlaceholder(final Traversal.Admin traversal, final String edgeLabel) {
@@ -40,10 +42,16 @@ public class AddEdgeStartStepPlaceholder extends AbstractAddEdgeStepPlaceholder<
                 (Traversal.Admin<Edge, String>) edgeLabelTraversal);
     }
 
+    public AddEdgeStartStepPlaceholder(final Traversal.Admin traversal, final Set<String> labels) {
+        super(traversal, labels);
+    }
+
     @Override
     public AddEdgeStartStep asConcreteStep() {
         AddEdgeStartStep step;
-        if (label instanceof Traversal) {
+        if (label instanceof Set) {
+            step = new AddEdgeStartStep(traversal, (Set<String>) label);
+        } else if (label instanceof Traversal) {
             step = new AddEdgeStartStep(traversal, ((Traversal<?, String>) label).asAdmin());
         } else if (label instanceof GValue) {
             step = new AddEdgeStartStep(traversal, ((GValue<String>) label).get());
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddEdgeStep.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddEdgeStep.java
index 753d9ae993..7073a7e80f 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddEdgeStep.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddEdgeStep.java
@@ -18,7 +18,10 @@
  */
 package org.apache.tinkerpop.gremlin.process.traversal.step.map;
 
+import java.util.Arrays;
 import java.util.Collections;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -62,6 +65,15 @@ public class AddEdgeStep<S> extends ScalarMapStep<S, Edge> implements AddEdgeSte
         this.internalParameters.set(this, T.label, edgeLabelTraversal);
     }
 
+    public AddEdgeStep(final Traversal.Admin traversal, final Set<String> labels) {
+        super(traversal);
+        if (labels == null || labels.isEmpty()) {
+            this.internalParameters.set(this, T.label, Edge.DEFAULT_LABEL);
+        } else {
+            this.internalParameters.set(this, T.label, labels);
+        }
+    }
+
     @Override
     public <S, E> List<Traversal.Admin<S, E>> getLocalChildren() {
         return this.internalParameters.getTraversals();
@@ -109,7 +121,21 @@ public class AddEdgeStep<S> extends ScalarMapStep<S, Edge> implements AddEdgeSte
 
     @Override
     protected Edge map(final Traverser.Admin<S> traverser) {
-        final String edgeLabel = this.internalParameters.get(traverser, T.label, () -> Edge.DEFAULT_LABEL).get(0);
+        final Object labelParam = this.internalParameters.get(traverser, T.label, () -> Edge.DEFAULT_LABEL).get(0);
+        final String edgeLabel;
+        final Set<String> additionalLabels;
+        if (labelParam instanceof Set) {
+            final Set<String> labelSet = (Set<String>) labelParam;
+            final Iterator<String> iter = labelSet.iterator();
+            edgeLabel = iter.next();
+            additionalLabels = new LinkedHashSet<>();
+            while (iter.hasNext()) {
+                additionalLabels.add(iter.next());
+            }
+        } else {
+            edgeLabel = (String) labelParam;
+            additionalLabels = Collections.emptySet();
+        }
 
         Vertex toVertex = getAdjacentVertex(this.internalParameters, TO, traverser, edgeLabel);
         Vertex fromVertex = getAdjacentVertex(this.internalParameters, FROM, traverser, edgeLabel);
@@ -135,6 +161,10 @@ public class AddEdgeStep<S> extends ScalarMapStep<S, Edge> implements AddEdgeSte
         }
 
         final Edge edge = fromVertex.addEdge(edgeLabel, toVertex, this.internalParameters.getKeyValues(traverser, TO, FROM, T.label));
+        if (!additionalLabels.isEmpty()) {
+            final String[] extra = additionalLabels.toArray(new String[0]);
+            edge.addLabel(extra[0], Arrays.copyOfRange(extra, 1, extra.length));
+        }
         EventUtil.registerEdgeCreation(callbackRegistry, getTraversal(), edge);
         return edge;
     }
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddEdgeStepPlaceholder.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddEdgeStepPlaceholder.java
index a6a5a4466a..a992a1314a 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddEdgeStepPlaceholder.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddEdgeStepPlaceholder.java
@@ -24,6 +24,8 @@ import org.apache.tinkerpop.gremlin.process.traversal.lambda.GValueConstantTrave
 import org.apache.tinkerpop.gremlin.process.traversal.step.GValue;
 import org.apache.tinkerpop.gremlin.structure.Edge;
 
+import java.util.Set;
+
 public class AddEdgeStepPlaceholder<S> extends AbstractAddEdgeStepPlaceholder<S> {
 
     public AddEdgeStepPlaceholder(final Traversal.Admin traversal, final String edgeLabel) {
@@ -39,10 +41,16 @@ public class AddEdgeStepPlaceholder<S> extends AbstractAddEdgeStepPlaceholder<S>
                 new ConstantTraversal<>(Edge.DEFAULT_LABEL) : edgeLabelTraversal);
     }
 
+    public AddEdgeStepPlaceholder(final Traversal.Admin traversal, final Set<String> labels) {
+        super(traversal, labels);
+    }
+
     @Override
     public AddEdgeStep<S> asConcreteStep() {
         AddEdgeStep<S> step;
-        if (label instanceof Traversal) {
+        if (label instanceof Set) {
+            step = new AddEdgeStep<>(traversal, (Set<String>) label);
+        } else if (label instanceof Traversal) {
             step = new AddEdgeStep<>(traversal, ((Traversal<S, String>) label).asAdmin());
         } else if (label instanceof GValue) {
             step = new AddEdgeStep<>(traversal, ((GValue<String>) label).get());
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddVertexStartStep.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddVertexStartStep.java
index 7718cc2883..5f109ae426 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddVertexStartStep.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddVertexStartStep.java
@@ -63,6 +63,17 @@ public class AddVertexStartStep extends AbstractStep<Vertex, Vertex> implements
         userProvidedLabel = vertexLabelTraversal != null;
     }
 
+    public AddVertexStartStep(final Traversal.Admin traversal, final Set<String> labels) {
+        super(traversal);
+        if (labels == null || labels.isEmpty()) {
+            this.internalParameters.set(this, T.label, Vertex.DEFAULT_LABEL);
+            userProvidedLabel = false;
+        } else {
+            this.internalParameters.set(this, T.label, labels);
+            userProvidedLabel = true;
+        }
+    }
+
     @Override
     public boolean hasUserProvidedLabel() {
         return userProvidedLabel;
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddVertexStartStepPlaceholder.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddVertexStartStepPlaceholder.java
index e84f4a7f1c..a1b5fa2449 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddVertexStartStepPlaceholder.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddVertexStartStepPlaceholder.java
@@ -24,6 +24,8 @@ import org.apache.tinkerpop.gremlin.process.traversal.step.GValue;
 import org.apache.tinkerpop.gremlin.process.traversal.step.GValueHolder;
 import org.apache.tinkerpop.gremlin.structure.Vertex;
 
+import java.util.Set;
+
 public class AddVertexStartStepPlaceholder extends AbstractAddVertexStepPlaceholder<Vertex>
         implements AddVertexStepContract<Vertex>, GValueHolder<Vertex, Vertex> {
 
@@ -40,10 +42,16 @@ public class AddVertexStartStepPlaceholder extends AbstractAddVertexStepPlacehol
                 new ConstantTraversal<>(Vertex.DEFAULT_LABEL) : (Traversal.Admin<Vertex,String>) vertexLabelTraversal);
     }
 
+    public AddVertexStartStepPlaceholder(final Traversal.Admin traversal, final Set<String> labels) {
+        super(traversal, labels);
+    }
+
     @Override
     public AddVertexStartStep asConcreteStep() {
         AddVertexStartStep step;
-        if (label instanceof Traversal) {
+        if (label instanceof Set) {
+            step = new AddVertexStartStep(traversal, (Set<String>) label);
+        } else if (label instanceof Traversal) {
             step = new AddVertexStartStep(traversal, ((Traversal<?, String>) label).asAdmin());
         } else if (label instanceof GValue) {
             step = new AddVertexStartStep(traversal, ((GValue<String>) label).get());
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddVertexStep.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddVertexStep.java
index b015920e17..4c2b505b53 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddVertexStep.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddVertexStep.java
@@ -59,6 +59,17 @@ public class AddVertexStep<S> extends ScalarMapStep<S, Vertex> implements AddVer
         userProvidedLabel = vertexLabelTraversal != null;
     }
 
+    public AddVertexStep(final Traversal.Admin traversal, final Set<String> labels) {
+        super(traversal);
+        if (labels == null || labels.isEmpty()) {
+            this.internalParameters.set(this, T.label, Vertex.DEFAULT_LABEL);
+            userProvidedLabel = false;
+        } else {
+            this.internalParameters.set(this, T.label, labels);
+            userProvidedLabel = true;
+        }
+    }
+
     @Override
     public boolean hasUserProvidedLabel() {
         return userProvidedLabel;
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddVertexStepPlaceholder.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddVertexStepPlaceholder.java
index 505bc47c1f..b749760051 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddVertexStepPlaceholder.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/AddVertexStepPlaceholder.java
@@ -22,6 +22,8 @@ import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
 import org.apache.tinkerpop.gremlin.process.traversal.lambda.GValueConstantTraversal;
 import org.apache.tinkerpop.gremlin.process.traversal.step.GValue;
 
+import java.util.Set;
+
 public class AddVertexStepPlaceholder<S> extends AbstractAddVertexStepPlaceholder<S> {
 
     public AddVertexStepPlaceholder(Traversal.Admin traversal, String label) {
@@ -36,10 +38,16 @@ public class AddVertexStepPlaceholder<S> extends AbstractAddVertexStepPlaceholde
         super(traversal, vertexLabelTraversal);
     }
 
+    public AddVertexStepPlaceholder(Traversal.Admin traversal, Set<String> labels) {
+        super(traversal, labels);
+    }
+
     @Override
     public AddVertexStep<S> asConcreteStep() {
         AddVertexStep<S> step;
-        if (label instanceof Traversal) {
+        if (label instanceof Set) {
+            step = new AddVertexStep<>(traversal, (Set<String>) label);
+        } else if (label instanceof Traversal) {
             step = new AddVertexStep<>(traversal, ((Traversal<S, String>) label).asAdmin());
         } else if (label instanceof GValue) {
             step = new AddVertexStep<>(traversal, ((GValue<String>) label).get());
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/ElementMapStep.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/ElementMapStep.java
index 370b0cd059..b05e620849 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/ElementMapStep.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/ElementMapStep.java
@@ -25,7 +25,6 @@ import org.apache.tinkerpop.gremlin.process.traversal.step.GraphComputing;
 import org.apache.tinkerpop.gremlin.process.traversal.step.TraversalParent;
 import org.apache.tinkerpop.gremlin.process.traversal.step.util.Parameters;
 import org.apache.tinkerpop.gremlin.process.traversal.step.util.WithOptions;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.OptionsStrategy;
 import org.apache.tinkerpop.gremlin.process.traversal.traverser.TraverserRequirement;
 import org.apache.tinkerpop.gremlin.structure.Direction;
 import org.apache.tinkerpop.gremlin.structure.Edge;
@@ -131,10 +130,7 @@ public class ElementMapStep<K,E> extends ScalarMapStep<Element, Map<K, E>> imple
      * or source-level {@code g.with("multilabel")}.
      */
     private boolean isMultilabelEnabled() {
-        if (this.multilabel) return true;
-        return getTraversal().getStrategies().getStrategy(OptionsStrategy.class)
-                .map(os -> os.getOptions().containsKey("multilabel") || os.getOptions().containsKey(WithOptions.multilabel))
-                .orElse(false);
+        return WithOptions.isMultilabelEnabled(this.multilabel, getTraversal());
     }
 
     public String[] getPropertyKeys() {
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/MergeEdgeStep.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/MergeEdgeStep.java
index 3535143192..261ab78eb8 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/MergeEdgeStep.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/MergeEdgeStep.java
@@ -20,6 +20,7 @@ package org.apache.tinkerpop.gremlin.process.traversal.step.map;
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
@@ -166,17 +167,21 @@ public class MergeEdgeStep<S> extends MergeElementStep<S, Edge, Map<Object, Obje
         final Graph graph = getGraph();
 
         final Object edgeId = search.get(T.id);
-        final String edgeLabel = (String) search.get(T.label);
+        final Object labelValue = search.get(T.label);
         final Object fromId = search.get(Direction.OUT);
         final Object toId = search.get(Direction.IN);
 
+        // Extract a single label string for use in outE(label)/inE(label) calls.
+        // For multi-label (collection), we use hasLabel() chaining instead.
+        final String singleLabel = labelValue instanceof String ? (String) labelValue : null;
+        final boolean hasLabelConstraint = labelValue != null;
+
         GraphTraversal t;
         if (edgeId != null) {
 
             // g.E(eid).hasLabel(label).where(outV().hasId(fromId)).where(inV().hasId(toId));
             t = graph.traversal().E(edgeId);
-            if (edgeLabel != null)
-                t = t.hasLabel(edgeLabel);
+            t = applyLabelConstraint(t, labelValue);
             if (fromId != null)
                 t = t.where(outV().hasId(fromId));
             if (toId != null)
@@ -186,10 +191,14 @@ public class MergeEdgeStep<S> extends MergeElementStep<S, Edge, Map<Object, Obje
 
             // g.V(fromId).outE(label).where(inV().hasId(toId));
             t = graph.traversal().V(fromId);
-            if (edgeLabel != null)
-                t = t.outE(edgeLabel);
-            else
+            if (singleLabel != null)
+                t = t.outE(singleLabel);
+            else {
                 t = t.outE();
+                // apply multi-label constraint after outE() if it's a collection
+                if (hasLabelConstraint && singleLabel == null)
+                    t = applyLabelConstraint(t, labelValue);
+            }
             if (toId != null)
                 t = t.where(inV().hasId(toId));
 
@@ -197,17 +206,20 @@ public class MergeEdgeStep<S> extends MergeElementStep<S, Edge, Map<Object, Obje
 
             // g.V(toId).inE(edgeLabel);
             t = graph.traversal().V(toId);
-            if (edgeLabel != null)
-                t = t.inE(edgeLabel);
-            else
+            if (singleLabel != null)
+                t = t.inE(singleLabel);
+            else {
                 t = t.inE();
+                // apply multi-label constraint after inE() if it's a collection
+                if (hasLabelConstraint && singleLabel == null)
+                    t = applyLabelConstraint(t, labelValue);
+            }
 
         } else {
 
             // g.E().hasLabel(label)
             t = graph.traversal().E();
-            if (edgeLabel != null)
-                t = t.hasLabel(edgeLabel);
+            t = applyLabelConstraint(t, labelValue);
 
         }
 
@@ -222,6 +234,26 @@ public class MergeEdgeStep<S> extends MergeElementStep<S, Edge, Map<Object, Obje
         return CloseableIterator.of(t);
     }
 
+    /**
+     * Apply label constraint(s) to the traversal. Supports both single String labels and
+     * Collection labels with AND semantics (edge must have ALL specified labels).
+     */
+    protected GraphTraversal applyLabelConstraint(GraphTraversal t, final Object labelValue) {
+        if (labelValue == null) {
+            return t;
+        }
+        if (labelValue instanceof String) {
+            return t.hasLabel((String) labelValue);
+        } else if (labelValue instanceof java.util.Collection) {
+            // Multi-label: AND semantics - must have ALL specified labels
+            for (final Object label : (java.util.Collection<?>) labelValue) {
+                t = t.hasLabel((String) label);
+            }
+            return t;
+        }
+        return t;
+    }
+
     protected Map<?,?> resolveVertices(final Map map, final Traverser.Admin<S> traverser) {
         resolveVertex(Merge.outV, Direction.OUT, map, traverser, outVTraversal);
         resolveVertex(Merge.inV, Direction.IN, map, traverser, inVTraversal);
@@ -279,14 +311,34 @@ public class MergeEdgeStep<S> extends MergeElementStep<S, Edge, Map<Object, Obje
                 traverser.set((S) e);
 
                 // assume good input from GraphTraversal - folks might drop in a T here even though it is immutable
-                final Map<String, ?> onMatchMap = materializeMap(traverser, onMatchTraversal);
+                final Map onMatchMap = materializeMap(traverser, onMatchTraversal);
                 validateMapInput(onMatchMap, true);
 
                 onMatchMap.forEach((key, value) -> {
+                    // Handle T.label replacement for multi-label support
+                    if (T.label.equals(key) || T.label.getAccessor().equals(key)) {
+                        // Drop all existing labels and replace with new ones
+                        e.dropLabels();
+                        if (value instanceof String) {
+                            e.addLabel((String) value);
+                        } else if (value instanceof java.util.Collection) {
+                            final java.util.Collection<?> labels = (java.util.Collection<?>) value;
+                            if (!labels.isEmpty()) {
+                                final String[] labelArray = labels.stream()
+                                        .map(l -> (String) l)
+                                        .toArray(String[]::new);
+                                e.addLabel(labelArray[0],
+                                        Arrays.copyOfRange(labelArray, 1, labelArray.length));
+                            }
+                            // Empty collection = use default label behavior (already handled by dropLabels())
+                        }
+                        return;
+                    }
+
                     // trigger callbacks for eventing - in this case, it's a EdgePropertyChangedEvent. if there's no
                     // registry/callbacks then just set the property
-                    EventUtil.registerEdgePropertyChange(callbackRegistry, getTraversal(), e, key, value);
-                    e.property(key, value);
+                    EventUtil.registerEdgePropertyChange(callbackRegistry, getTraversal(), e, (String) key, value);
+                    e.property((String) key, value);
                 });
 
             });
@@ -317,7 +369,30 @@ public class MergeEdgeStep<S> extends MergeElementStep<S, Edge, Map<Object, Obje
 
         final Vertex fromV = resolveVertex(onCreateMap.get(Direction.OUT));
         final Vertex toV = resolveVertex(onCreateMap.get(Direction.IN));
-        final String label = (String) onCreateMap.getOrDefault(T.label, Edge.DEFAULT_LABEL);
+        final Object labelValue = onCreateMap.getOrDefault(T.label, Edge.DEFAULT_LABEL);
+        final String primaryLabel;
+        final java.util.Collection<String> additionalLabels;
+
+        if (labelValue instanceof String) {
+            primaryLabel = (String) labelValue;
+            additionalLabels = Collections.emptyList();
+        } else if (labelValue instanceof java.util.Collection) {
+            final java.util.Collection<?> labelCollection = (java.util.Collection<?>) labelValue;
+            if (labelCollection.isEmpty()) {
+                primaryLabel = Edge.DEFAULT_LABEL;
+                additionalLabels = Collections.emptyList();
+            } else {
+                final Iterator<?> iter = labelCollection.iterator();
+                primaryLabel = (String) iter.next();
+                additionalLabels = new ArrayList<>();
+                while (iter.hasNext()) {
+                    additionalLabels.add((String) iter.next());
+                }
+            }
+        } else {
+            primaryLabel = Edge.DEFAULT_LABEL;
+            additionalLabels = Collections.emptyList();
+        }
 
         final List<Object> properties = new ArrayList<>();
 
@@ -329,7 +404,13 @@ public class MergeEdgeStep<S> extends MergeElementStep<S, Edge, Map<Object, Obje
             properties.add(e.getValue());
         }
 
-        final Edge edge = fromV.addEdge(label, toV, properties.toArray());
+        final Edge edge = fromV.addEdge(primaryLabel, toV, properties.toArray());
+
+        // add any additional labels from a multi-label collection
+        if (!additionalLabels.isEmpty()) {
+            final String[] extraLabels = additionalLabels.toArray(new String[0]);
+            edge.addLabel(extraLabels[0], Arrays.copyOfRange(extraLabels, 1, extraLabels.length));
+        }
 
         // trigger callbacks for eventing - in this case, it's a VertexAddedEvent
         EventUtil.registerEdgeCreationWithGenericEventRegistry(callbackRegistry, getTraversal(), edge);
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/PropertyMapStep.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/PropertyMapStep.java
index 25bc143bc3..665ea10e4b 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/PropertyMapStep.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/PropertyMapStep.java
@@ -25,7 +25,6 @@ import org.apache.tinkerpop.gremlin.process.traversal.step.Configuring;
 import org.apache.tinkerpop.gremlin.process.traversal.step.TraversalParent;
 import org.apache.tinkerpop.gremlin.process.traversal.step.util.Parameters;
 import org.apache.tinkerpop.gremlin.process.traversal.step.util.WithOptions;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.OptionsStrategy;
 import org.apache.tinkerpop.gremlin.process.traversal.traverser.TraverserRequirement;
 import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalProduct;
 import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalUtil;
@@ -220,10 +219,7 @@ public class PropertyMapStep<K,E> extends ScalarMapStep<Element, Map<K, E>>
      * or source-level {@code g.with("multilabel")}.
      */
     private boolean isMultilabelEnabled() {
-        if (this.multilabel) return true;
-        return getTraversal().getStrategies().getStrategy(OptionsStrategy.class)
-                .map(os -> os.getOptions().containsKey("multilabel") || os.getOptions().containsKey(WithOptions.multilabel))
-                .orElse(false);
+        return WithOptions.isMultilabelEnabled(this.multilabel, getTraversal());
     }
 
     protected Object getElementId(Element element){
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/sideEffect/AddLabelStep.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/sideEffect/AddLabelStep.java
index c239623601..1cb2d01108 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/sideEffect/AddLabelStep.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/sideEffect/AddLabelStep.java
@@ -26,7 +26,6 @@ import org.apache.tinkerpop.gremlin.process.traversal.step.util.event.CallbackRe
 import org.apache.tinkerpop.gremlin.process.traversal.step.util.event.Event;
 import org.apache.tinkerpop.gremlin.process.traversal.step.util.event.EventUtil;
 import org.apache.tinkerpop.gremlin.process.traversal.step.util.event.ListCallbackRegistry;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.EventStrategy;
 import org.apache.tinkerpop.gremlin.process.traversal.traverser.TraverserRequirement;
 import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalUtil;
 import org.apache.tinkerpop.gremlin.structure.Element;
@@ -36,9 +35,9 @@ import org.apache.tinkerpop.gremlin.structure.util.StringFactory;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Objects;
-import java.util.Optional;
 import java.util.Set;
 
 /**
@@ -48,11 +47,11 @@ import java.util.Set;
  * @since 4.0.0
  */
 public class AddLabelStep<S extends Element> extends SideEffectStep<S>
-        implements Mutating<Event.ElementPropertyChangedEvent>, TraversalParent {
+        implements Mutating<Event.ElementLabelChangedEvent>, TraversalParent {
 
     private final String[] labels;
     private Traversal.Admin<S, String> labelTraversal;
-    private CallbackRegistry<Event.ElementPropertyChangedEvent> callbackRegistry;
+    private CallbackRegistry<Event.ElementLabelChangedEvent> callbackRegistry;
 
     public AddLabelStep(final Traversal.Admin traversal, final String label, final String... moreLabels) {
         super(traversal);
@@ -76,6 +75,7 @@ public class AddLabelStep<S extends Element> extends SideEffectStep<S>
     @Override
     protected void sideEffect(final Traverser.Admin<S> traverser) {
         final Element element = traverser.get();
+        final Set<String> oldLabels = new LinkedHashSet<>(element.labels());
 
         if (this.labelTraversal != null) {
             final List<String> collectedLabels = new ArrayList<>();
@@ -93,16 +93,14 @@ public class AddLabelStep<S extends Element> extends SideEffectStep<S>
                     Arrays.copyOfRange(this.labels, 1, this.labels.length));
         }
 
-        // trigger event callbacks
-        final Optional<EventStrategy> optEventStrategy = getTraversal().getStrategies().getStrategy(EventStrategy.class);
-        if (EventUtil.hasAnyCallbacks(callbackRegistry) && optEventStrategy.isPresent()) {
-            final EventStrategy es = optEventStrategy.get();
-            EventUtil.registerPropertyChange(callbackRegistry, es, element, null, null, new Object[0]);
+        // trigger event callbacks only if labels actually changed
+        if (!oldLabels.equals(element.labels())) {
+            EventUtil.registerLabelChange(callbackRegistry, getTraversal(), element, oldLabels, element.labels());
         }
     }
 
     @Override
-    public CallbackRegistry<Event.ElementPropertyChangedEvent> getMutatingCallbackRegistry() {
+    public CallbackRegistry<Event.ElementLabelChangedEvent> getMutatingCallbackRegistry() {
         if (null == callbackRegistry) callbackRegistry = new ListCallbackRegistry<>();
         return callbackRegistry;
     }
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/sideEffect/DropLabelsStep.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/sideEffect/DropLabelsStep.java
index 14e5d0634f..9812b0b786 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/sideEffect/DropLabelsStep.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/sideEffect/DropLabelsStep.java
@@ -26,7 +26,6 @@ import org.apache.tinkerpop.gremlin.process.traversal.step.util.event.CallbackRe
 import org.apache.tinkerpop.gremlin.process.traversal.step.util.event.Event;
 import org.apache.tinkerpop.gremlin.process.traversal.step.util.event.EventUtil;
 import org.apache.tinkerpop.gremlin.process.traversal.step.util.event.ListCallbackRegistry;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.EventStrategy;
 import org.apache.tinkerpop.gremlin.process.traversal.traverser.TraverserRequirement;
 import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalUtil;
 import org.apache.tinkerpop.gremlin.structure.Element;
@@ -35,8 +34,8 @@ import org.apache.tinkerpop.gremlin.structure.util.StringFactory;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.LinkedHashSet;
 import java.util.List;
-import java.util.Optional;
 import java.util.Set;
 
 /**
@@ -46,12 +45,12 @@ import java.util.Set;
  * @since 4.0.0
  */
 public class DropLabelsStep<S extends Element> extends SideEffectStep<S>
-        implements Mutating<Event.ElementPropertyChangedEvent>, TraversalParent {
+        implements Mutating<Event.ElementLabelChangedEvent>, TraversalParent {
 
     private final boolean dropAll;
     private final String[] labels;
     private Traversal.Admin<S, String> labelTraversal;
-    private CallbackRegistry<Event.ElementPropertyChangedEvent> callbackRegistry;
+    private CallbackRegistry<Event.ElementLabelChangedEvent> callbackRegistry;
 
     /**
      * Constructor for dropLabels() - removes all labels.
@@ -89,6 +88,7 @@ public class DropLabelsStep<S extends Element> extends SideEffectStep<S>
     @Override
     protected void sideEffect(final Traverser.Admin<S> traverser) {
         final Element element = traverser.get();
+        final Set<String> oldLabels = new LinkedHashSet<>(element.labels());
 
         if (this.labelTraversal != null) {
             final String label = TraversalUtil.apply(traverser, this.labelTraversal);
@@ -102,16 +102,14 @@ public class DropLabelsStep<S extends Element> extends SideEffectStep<S>
                     Arrays.copyOfRange(this.labels, 1, this.labels.length));
         }
 
-        // trigger event callbacks
-        final Optional<EventStrategy> optEventStrategy = getTraversal().getStrategies().getStrategy(EventStrategy.class);
-        if (EventUtil.hasAnyCallbacks(callbackRegistry) && optEventStrategy.isPresent()) {
-            final EventStrategy es = optEventStrategy.get();
-            EventUtil.registerPropertyChange(callbackRegistry, es, element, null, null, new Object[0]);
+        // trigger event callbacks only if labels actually changed
+        if (!oldLabels.equals(element.labels())) {
+            EventUtil.registerLabelChange(callbackRegistry, getTraversal(), element, oldLabels, element.labels());
         }
     }
 
     @Override
-    public CallbackRegistry<Event.ElementPropertyChangedEvent> getMutatingCallbackRegistry() {
+    public CallbackRegistry<Event.ElementLabelChangedEvent> getMutatingCallbackRegistry() {
         if (null == callbackRegistry) callbackRegistry = new ListCallbackRegistry<>();
         return callbackRegistry;
     }
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/WithOptions.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/WithOptions.java
index 9be8e4f939..8b7df79f02 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/WithOptions.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/WithOptions.java
@@ -18,8 +18,10 @@
  */
 package org.apache.tinkerpop.gremlin.process.traversal.step.util;
 
+import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.IndexStep;
+import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.OptionsStrategy;
 import org.apache.tinkerpop.gremlin.structure.Edge;
 import org.apache.tinkerpop.gremlin.structure.Element;
 import org.apache.tinkerpop.gremlin.structure.Graph;
@@ -102,4 +104,20 @@ public class WithOptions {
      * @since 4.0.0
      */
     public static final String multilabel = Graph.Hidden.hide("tinkerpop.multilabel");
+
+    /**
+     * The user-facing key for multilabel configuration used with {@code g.with("multilabel")}.
+     */
+    public static final String MULTILABEL_KEY = "multilabel";
+
+    /**
+     * Checks whether multi-label output is enabled for the given traversal, either at the step level
+     * (via step-level configuration) or at the source level (via {@code g.with("multilabel")}).
+     */
+    public static boolean isMultilabelEnabled(final boolean stepLevelEnabled, final Traversal.Admin<?, ?> traversal) {
+        if (stepLevelEnabled) return true;
+        return traversal.getStrategies().getStrategy(OptionsStrategy.class)
+                .map(os -> os.getOptions().containsKey(MULTILABEL_KEY) || os.getOptions().containsKey(multilabel))
+                .orElse(false);
+    }
 }
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/event/Event.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/event/Event.java
index 4a9d9c06e6..f02e6bc63f 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/event/Event.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/event/Event.java
@@ -27,6 +27,7 @@ import org.apache.tinkerpop.gremlin.structure.Vertex;
 import org.apache.tinkerpop.gremlin.structure.VertexProperty;
 
 import java.util.Iterator;
+import java.util.Set;
 
 /**
  * A representation of some action that occurs on a {@link Graph} for a {@link Traversal}.
@@ -213,6 +214,31 @@ public interface Event {
         }
     }
 
+    /**
+     * An event that represents a label change on an element (vertex or edge).
+     * Fired when labels are added or removed via addLabel()/dropLabel()/dropLabels() steps.
+     */
+    class ElementLabelChangedEvent implements Event {
+        private final Element element;
+        private final Set<String> oldLabels;
+        private final Set<String> newLabels;
+
+        public ElementLabelChangedEvent(final Element element, final Set<String> oldLabels, final Set<String> newLabels) {
+            this.element = element;
+            this.oldLabels = oldLabels;
+            this.newLabels = newLabels;
+        }
+
+        public Element getElement() { return element; }
+        public Set<String> getOldLabels() { return oldLabels; }
+        public Set<String> getNewLabels() { return newLabels; }
+
+        @Override
+        public void fireEvent(final Iterator<MutationListener> eventListeners) {
+            // Label change events are dispatched directly via CallbackRegistry, not MutationListener.
+        }
+    }
+
     /**
      * A base class for {@link Property} mutation events.
      */
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/event/EventUtil.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/event/EventUtil.java
index 2fce97e150..85d8072f89 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/event/EventUtil.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/event/EventUtil.java
@@ -27,6 +27,8 @@ import org.apache.tinkerpop.gremlin.structure.Property;
 import org.apache.tinkerpop.gremlin.structure.Vertex;
 import org.apache.tinkerpop.gremlin.structure.VertexProperty;
 
+import java.util.Set;
+
 /**
  * Logic for registering events with the {@link EventStrategy} and the callback registry. Extracting this logic allows
  * providers to reuse these utilities more readily.
@@ -202,6 +204,24 @@ public final class EventUtil {
         }
     }
 
+    /**
+     * Register a label change event with the callback registry.
+     */
+    @SuppressWarnings("unchecked")
+    public static void registerLabelChange(final CallbackRegistry<Event.ElementLabelChangedEvent> callbackRegistry,
+                                           final Traversal.Admin<?, ?> traversal, final Element element,
+                                           final Set<String> oldLabels, final Set<String> newLabels) {
+        if (hasAnyCallbacks(callbackRegistry)) {
+            final EventStrategy eventStrategy = ((Traversal.Admin<Object, Object>) traversal)
+                    .getStrategies().getStrategy(EventStrategy.class).orElse(null);
+            final Element detachedElement = eventStrategy != null ? eventStrategy.detach(element) : element;
+            final Event.ElementLabelChangedEvent event = new Event.ElementLabelChangedEvent(detachedElement, oldLabels, newLabels);
+            for (EventCallback<Event.ElementLabelChangedEvent> c : callbackRegistry.getCallbacks()) {
+                c.accept(event);
+            }
+        }
+    }
+
     /**
      * Register a vertex property addition event with the callback registry.
      */
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/binary/types/EdgeSerializer.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/binary/types/EdgeSerializer.java
index 6d614d5126..fe48d6f6ae 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/binary/types/EdgeSerializer.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/binary/types/EdgeSerializer.java
@@ -30,8 +30,11 @@ import org.apache.tinkerpop.gremlin.structure.util.detached.DetachedVertex;
 import org.apache.tinkerpop.gremlin.structure.util.reference.ReferenceEdge;
 
 import java.io.IOException;
+import java.util.ArrayList;
 import java.util.Collections;
+import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Set;
 
 /**
  * @author Stephen Mallette (http://stephen.genoprime.com)
@@ -44,25 +47,43 @@ public class EdgeSerializer extends SimpleTypeSerializer<Edge> {
     @Override
     protected Edge readValue(final Buffer buffer, final GraphBinaryReader context) throws IOException {
         final Object id = context.read(buffer);
-        // reading single string value for now according to GraphBinaryV4
-        final String label = (String) context.readValue(buffer, List.class, false).get(0);
+        // Read all labels as List<String> for multi-label support
+        final List<String> labelList = context.readValue(buffer, List.class, false);
 
         final Object inVId = context.read(buffer);
-        // reading single string value for now according to GraphBinaryV4
-        final String inVLabel = (String) context.readValue(buffer, List.class, false).get(0);
+        // Read all inVertex labels as List<String> for multi-label support
+        final List<String> inVLabelList = context.readValue(buffer, List.class, false);
         final Object outVId = context.read(buffer);
-        // reading single string value for now according to GraphBinaryV4
-        final String outVLabel = (String) context.readValue(buffer, List.class, false).get(0);
+        // Read all outVertex labels as List<String> for multi-label support
+        final List<String> outVLabelList = context.readValue(buffer, List.class, false);
 
         // discard the parent vertex
         context.read(buffer);
 
         final List<Property> properties = context.read(buffer);
 
-        final DetachedVertex inV = DetachedVertex.build().setId(inVId).setLabel(inVLabel).create();
-        final DetachedVertex outV = DetachedVertex.build().setId(outVId).setLabel(outVLabel).create();
+        final DetachedVertex.Builder inVBuilder = DetachedVertex.build().setId(inVId);
+        if (inVLabelList.size() == 1) {
+            inVBuilder.setLabel(inVLabelList.get(0));
+        } else if (!inVLabelList.isEmpty()) {
+            inVBuilder.setLabels(new LinkedHashSet<>(inVLabelList));
+        }
+        final DetachedVertex inV = inVBuilder.create();
+
+        final DetachedVertex.Builder outVBuilder = DetachedVertex.build().setId(outVId);
+        if (outVLabelList.size() == 1) {
+            outVBuilder.setLabel(outVLabelList.get(0));
+        } else if (!outVLabelList.isEmpty()) {
+            outVBuilder.setLabels(new LinkedHashSet<>(outVLabelList));
+        }
+        final DetachedVertex outV = outVBuilder.create();
 
-        final DetachedEdge.Builder builder = DetachedEdge.build().setId(id).setLabel(label).setInV(inV).setOutV(outV);
+        final DetachedEdge.Builder builder = DetachedEdge.build().setId(id).setInV(inV).setOutV(outV);
+        if (labelList.size() == 1) {
+            builder.setLabel(labelList.get(0));
+        } else if (!labelList.isEmpty()) {
+            builder.setLabels(new LinkedHashSet<>(labelList));
+        }
 
         if (properties != null) {
             for (final Property p : properties) {
@@ -77,16 +98,28 @@ public class EdgeSerializer extends SimpleTypeSerializer<Edge> {
     protected void writeValue(final Edge value, final Buffer buffer, final GraphBinaryWriter context) throws IOException {
 
         context.write(value.id(), buffer);
-        // wrapping label into list here for now according to GraphBinaryV4, but we aren't allowing null label yet
-        if (value.label() == null) {
-            throw new IOException("Unexpected null value when nullable is false");
+        // Write all edge labels as List<String> for multi-label support
+        final Set<String> edgeLabels = value.labels();
+        if (edgeLabels == null || edgeLabels.isEmpty()) {
+            throw new IOException("Unexpected null or empty labels when nullable is false");
         }
-        context.writeValue(Collections.singletonList(value.label()), buffer, false);
+        context.writeValue(new ArrayList<>(edgeLabels), buffer, false);
 
         context.write(value.inVertex().id(), buffer);
-        context.writeValue(Collections.singletonList(value.inVertex().label()), buffer, false);
+        // Write all inVertex labels as List<String> for multi-label support
+        final Set<String> inVLabels = value.inVertex().labels();
+        if (inVLabels == null || inVLabels.isEmpty()) {
+            throw new IOException("Unexpected null or empty labels when nullable is false");
+        }
+        context.writeValue(new ArrayList<>(inVLabels), buffer, false);
+
         context.write(value.outVertex().id(), buffer);
-        context.writeValue(Collections.singletonList(value.outVertex().label()), buffer, false);
+        // Write all outVertex labels as List<String> for multi-label support
+        final Set<String> outVLabels = value.outVertex().labels();
+        if (outVLabels == null || outVLabels.isEmpty()) {
+            throw new IOException("Unexpected null or empty labels when nullable is false");
+        }
+        context.writeValue(new ArrayList<>(outVLabels), buffer, false);
 
         // we don't serialize the parent Vertex for edges.
         context.write(null, buffer);
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/GraphSONSerializersV4.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/GraphSONSerializersV4.java
index bc1962f8db..afd27256fc 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/GraphSONSerializersV4.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/GraphSONSerializersV4.java
@@ -146,7 +146,7 @@ class GraphSONSerializersV4 {
             jsonGenerator.writeStartObject();
 
             jsonGenerator.writeObjectField(GraphSONTokens.ID, edge.id());
-            writeLabel(jsonGenerator, GraphSONTokens.LABEL, edge.label());
+            writeLabels(jsonGenerator, GraphSONTokens.LABEL, edge.labels());
             writeTypeForGraphObjectIfUntyped(jsonGenerator, typeInfo, GraphSONTokens.EDGE);
             writeVertex(GraphSONTokens.IN, edge.inVertex(), jsonGenerator);
             writeVertex(GraphSONTokens.OUT, edge.outVertex(), jsonGenerator);
@@ -160,7 +160,7 @@ class GraphSONSerializersV4 {
             jsonGenerator.writeFieldName(vertexDirection);
             jsonGenerator.writeStartObject();
             jsonGenerator.writeObjectField(GraphSONTokens.ID, v.id());
-            writeLabel(jsonGenerator, GraphSONTokens.LABEL, v.label());
+            writeLabels(jsonGenerator, GraphSONTokens.LABEL, v.labels());
             jsonGenerator.writeEndObject();
         }
 
@@ -439,8 +439,14 @@ class GraphSONSerializersV4 {
                     e.setId(deserializationContext.readValue(jsonParser, Object.class));
                 } else if (jsonParser.getCurrentName().equals(GraphSONTokens.LABEL)) {
                     jsonParser.nextToken();
+                    final java.util.Set<String> labels = new java.util.LinkedHashSet<>();
                     while (jsonParser.nextToken() != JsonToken.END_ARRAY) {
-                        e.setLabel(jsonParser.getText());
+                        labels.add(jsonParser.getText());
+                    }
+                    if (labels.size() == 1) {
+                        e.setLabel(labels.iterator().next());
+                    } else if (!labels.isEmpty()) {
+                        e.setLabels(labels);
                     }
                 } else if (jsonParser.getCurrentName().equals(GraphSONTokens.OUT)) {
                     jsonParser.nextToken();
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/util/detached/DetachedEdge.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/util/detached/DetachedEdge.java
index 2c91afb615..77f53876d4 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/util/detached/DetachedEdge.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/util/detached/DetachedEdge.java
@@ -30,8 +30,10 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Iterator;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * Represents an {@link Edge} that is disconnected from a {@link Graph}.  "Disconnection" can mean detachment from
@@ -51,6 +53,7 @@ public class DetachedEdge extends DetachedElement<Edge> implements Edge {
 
     private DetachedVertex outVertex;
     private DetachedVertex inVertex;
+    private Set<String> edgeLabels;
 
     private DetachedEdge() {}
 
@@ -59,6 +62,12 @@ public class DetachedEdge extends DetachedElement<Edge> implements Edge {
         this.outVertex = DetachedFactory.detach(edge.outVertex(), false);
         this.inVertex = DetachedFactory.detach(edge.inVertex(), false);
 
+        // Capture all labels from the source edge for multi-label support.
+        final Set<String> srcLabels = edge.labels();
+        if (srcLabels.size() > 1) {
+            this.edgeLabels = new LinkedHashSet<>(srcLabels);
+        }
+
         // only serialize properties if requested, the graph supports it and there are meta properties present.
         // this prevents unnecessary object creation of a new HashMap of a new HashMap which will just be empty.
         // it will use Collections.emptyMap() by default
@@ -113,6 +122,23 @@ public class DetachedEdge extends DetachedElement<Edge> implements Edge {
         return StringFactory.edgeString(this);
     }
 
+    @Override
+    public Set<String> labels() {
+        if (this.edgeLabels != null) {
+            return Collections.unmodifiableSet(this.edgeLabels);
+        }
+        // Fall back to single label from parent
+        return this.label != null ? Collections.singleton(this.label) : Collections.emptySet();
+    }
+
+    @Override
+    public String label() {
+        if (this.edgeLabels != null && !this.edgeLabels.isEmpty()) {
+            return this.edgeLabels.iterator().next();
+        }
+        return this.label != null ? this.label : Edge.DEFAULT_LABEL;
+    }
+
     @Override
     public Vertex inVertex() {
         return this.inVertex;
@@ -180,6 +206,14 @@ public class DetachedEdge extends DetachedElement<Edge> implements Edge {
             return this;
         }
 
+        public Builder setLabels(final Set<String> labels) {
+            e.edgeLabels = labels != null ? new LinkedHashSet<>(labels) : null;
+            if (labels != null && !labels.isEmpty()) {
+                e.label = labels.iterator().next();
+            }
+            return this;
+        }
+
         public Builder setOutV(final DetachedVertex v) {
             e.outVertex = v;
             return this;
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/util/reference/ReferenceEdge.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/util/reference/ReferenceEdge.java
index 6f716022ef..8f797b96b3 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/util/reference/ReferenceEdge.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/util/reference/ReferenceEdge.java
@@ -28,6 +28,8 @@ import org.apache.tinkerpop.gremlin.util.iterator.IteratorUtils;
 
 import java.util.Collections;
 import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.Set;
 
 /**
  * @author Marko A. Rodriguez (http://markorodriguez.com)
@@ -36,6 +38,7 @@ public class ReferenceEdge extends ReferenceElement<Edge> implements Edge {
 
     private ReferenceVertex inVertex;
     private ReferenceVertex outVertex;
+    private Set<String> edgeLabels;
 
     private ReferenceEdge() {
 
@@ -45,6 +48,11 @@ public class ReferenceEdge extends ReferenceElement<Edge> implements Edge {
         super(edge);
         this.inVertex = new ReferenceVertex(edge.inVertex());
         this.outVertex = new ReferenceVertex(edge.outVertex());
+        // Capture all labels from the source edge for multi-label support.
+        final Set<String> srcLabels = edge.labels();
+        if (srcLabels.size() > 1) {
+            this.edgeLabels = new LinkedHashSet<>(srcLabels);
+        }
     }
 
     public ReferenceEdge(final Object id, final String label, final ReferenceVertex inVertex, final ReferenceVertex outVertex) {
@@ -53,6 +61,29 @@ public class ReferenceEdge extends ReferenceElement<Edge> implements Edge {
         this.outVertex = outVertex;
     }
 
+    public ReferenceEdge(final Object id, final Set<String> labels, final ReferenceVertex inVertex, final ReferenceVertex outVertex) {
+        super(id, labels != null && !labels.isEmpty() ? labels.iterator().next() : Edge.DEFAULT_LABEL);
+        this.edgeLabels = labels != null ? new LinkedHashSet<>(labels) : null;
+        this.inVertex = inVertex;
+        this.outVertex = outVertex;
+    }
+
+    @Override
+    public Set<String> labels() {
+        if (this.edgeLabels != null) {
+            return Collections.unmodifiableSet(this.edgeLabels);
+        }
+        return this.label != null ? Collections.singleton(this.label) : Collections.emptySet();
+    }
+
+    @Override
+    public String label() {
+        if (this.edgeLabels != null && !this.edgeLabels.isEmpty()) {
+            return this.edgeLabels.iterator().next();
+        }
+        return this.label != null ? this.label : Edge.DEFAULT_LABEL;
+    }
+
     @Override
     public <V> Property<V> property(final String key, final V value) {
         throw Element.Exceptions.propertyAdditionNotSupported();
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/util/star/StarGraph.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/util/star/StarGraph.java
index 8daaf64aef..1981a3257b 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/util/star/StarGraph.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/util/star/StarGraph.java
@@ -43,6 +43,7 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.NoSuchElementException;
@@ -206,6 +207,12 @@ public final class StarGraph implements Graph, Serializable {
         final StarGraph starGraph = new StarGraph();
         final StarVertex starVertex = (StarVertex) starGraph.addVertex(T.id, vertex.id(), T.label, vertex.label());
 
+        // Copy multi-labels from source vertex
+        final Set<String> srcLabels = vertex.labels();
+        if (srcLabels.size() > 1) {
+            starVertex.setLabels(srcLabels);
+        }
+
         final boolean supportsMetaProperties = vertex.graph().features().vertex().supportsMetaProperties();
 
         vertex.properties().forEachRemaining(vp -> {
@@ -216,11 +223,19 @@ public final class StarGraph implements Graph, Serializable {
         vertex.edges(Direction.IN).forEachRemaining(edge -> {
             final Edge starEdge = starVertex.addInEdge(edge.label(), starGraph.addVertex(T.id, edge.outVertex().id()), T.id, edge.id());
             edge.properties().forEachRemaining(p -> starEdge.property(p.key(), p.value()));
+            final Set<String> edgeSrcLabels = edge.labels();
+            if (edgeSrcLabels.size() > 1) {
+                ((StarGraph.StarEdge) starEdge).setLabels(edgeSrcLabels);
+            }
         });
 
         vertex.edges(Direction.OUT).forEachRemaining(edge -> {
             final Edge starEdge = starVertex.addOutEdge(edge.label(), starGraph.addVertex(T.id, edge.inVertex().id()), T.id, edge.id());
             edge.properties().forEachRemaining(p -> starEdge.property(p.key(), p.value()));
+            final Set<String> edgeSrcLabels = edge.labels();
+            if (edgeSrcLabels.size() > 1) {
+                ((StarGraph.StarEdge) starEdge).setLabels(edgeSrcLabels);
+            }
         });
         return starGraph;
     }
@@ -308,7 +323,7 @@ public final class StarGraph implements Graph, Serializable {
     public abstract class StarElement<E extends Element> implements Element, Attachable<E> {
 
         protected final Object id;
-        protected final String label;
+        protected String label;
 
         protected StarElement(final Object id, final String label) {
             this.id = id;
@@ -352,12 +367,35 @@ public final class StarGraph implements Graph, Serializable {
 
     public final class StarVertex extends StarElement<Vertex> implements Vertex {
 
+        private Set<String> vertexLabels;
         protected Map<String, List<Edge>> outEdges = null;
         protected Map<String, List<Edge>> inEdges = null;
         protected Map<String, List<VertexProperty>> vertexProperties = null;
 
         public StarVertex(final Object id, final String label) {
             super(id, label);
+            this.vertexLabels = new LinkedHashSet<>();
+            this.vertexLabels.add(internStrings ? label.intern() : label);
+        }
+
+        @Override
+        public Set<String> labels() {
+            return Collections.unmodifiableSet(this.vertexLabels);
+        }
+
+        @Override
+        public String label() {
+            return this.vertexLabels.isEmpty() ? this.label : this.vertexLabels.iterator().next();
+        }
+
+        /**
+         * Sets the vertex labels from a source set. Used when copying labels from a multi-label vertex.
+         */
+        public void setLabels(final Set<String> labels) {
+            if (labels != null && !labels.isEmpty()) {
+                this.vertexLabels = new LinkedHashSet<>(labels);
+                this.label = this.vertexLabels.iterator().next();
+            }
         }
 
         private void dropEdgeProperty(Object id) {
@@ -774,11 +812,34 @@ public final class StarGraph implements Graph, Serializable {
 
     public abstract class StarEdge extends StarElement<Edge> implements Edge {
 
+        private Set<String> edgeLabels;
         protected final Object otherId;
 
         private StarEdge(final Object id, final String label, final Object otherId) {
             super(id, label);
             this.otherId = otherId;
+            this.edgeLabels = new LinkedHashSet<>();
+            this.edgeLabels.add(internStrings ? label.intern() : label);
+        }
+
+        @Override
+        public Set<String> labels() {
+            return Collections.unmodifiableSet(this.edgeLabels);
+        }
+
+        @Override
+        public String label() {
+            return this.edgeLabels.isEmpty() ? this.label : this.edgeLabels.iterator().next();
+        }
+
+        /**
+         * Sets the edge labels from a source set. Used when copying labels from a multi-label edge.
+         */
+        public void setLabels(final Set<String> labels) {
+            if (labels != null && !labels.isEmpty()) {
+                this.edgeLabels = new LinkedHashSet<>(labels);
+                this.label = this.edgeLabels.iterator().next();
+            }
         }
 
         @Override
diff --git a/gremlin-language/src/main/antlr4/Gremlin.g4 b/gremlin-language/src/main/antlr4/Gremlin.g4
index af76bc0593..2d7fa316a6 100644
--- a/gremlin-language/src/main/antlr4/Gremlin.g4
+++ b/gremlin-language/src/main/antlr4/Gremlin.g4
@@ -111,7 +111,9 @@ traversalSourceSpawnMethod
     ;
 
 traversalSourceSpawnMethod_addE
-    : K_ADDE LPAREN stringArgument RPAREN
+    : K_ADDE LPAREN RPAREN
+    | K_ADDE LPAREN stringArgument RPAREN
+    | K_ADDE LPAREN stringArgument COMMA stringArgument (COMMA stringArgument)* RPAREN
     | K_ADDE LPAREN nestedTraversal RPAREN
     ;
 
@@ -325,7 +327,9 @@ traversalMethod_E
     ;
 
 traversalMethod_addE
-    : K_ADDE LPAREN stringArgument RPAREN #traversalMethod_addE_String
+    : K_ADDE LPAREN RPAREN #traversalMethod_addE_Empty
+    | K_ADDE LPAREN stringArgument RPAREN #traversalMethod_addE_String
+    | K_ADDE LPAREN stringArgument (COMMA stringArgument)+ RPAREN #traversalMethod_addE_StringVarargs
     | K_ADDE LPAREN nestedTraversal RPAREN #traversalMethod_addE_Traversal
     ;
 
diff --git a/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/AbstractTinkerGraph.java b/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/AbstractTinkerGraph.java
index cf9f72bd14..b2b5b99281 100644
--- a/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/AbstractTinkerGraph.java
+++ b/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/AbstractTinkerGraph.java
@@ -292,6 +292,26 @@ public abstract class AbstractTinkerGraph implements Graph {
 
     protected abstract void addInEdge(final TinkerVertex vertex, final String label, final Edge edge);
 
+    /**
+     * Add an edge to the per-vertex adjacency maps under the given label.
+     * Used when labels are added to an existing edge.
+     *
+     * @param edge  the edge to register
+     * @param label the label under which to register the edge
+     * @since 4.0.0
+     */
+    public abstract void addEdgeToAdjacency(final TinkerEdge edge, final String label);
+
+    /**
+     * Remove an edge from the per-vertex adjacency maps for the given label.
+     * Used when labels are removed from an existing edge.
+     *
+     * @param edge  the edge to unregister
+     * @param label the label from which to unregister the edge
+     * @since 4.0.0
+     */
+    public abstract void removeEdgeFromAdjacency(final TinkerEdge edge, final String label);
+
     /**
      * Called when a vertex's labels are modified to allow the graph to update any internal label indices.
      * The default implementation is a no-op since TinkerGraph does not maintain a separate label index.
diff --git a/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerEdge.java b/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerEdge.java
index 3ced83454e..b37913a0aa 100644
--- a/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerEdge.java
+++ b/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerEdge.java
@@ -30,6 +30,7 @@ import org.apache.tinkerpop.gremlin.util.iterator.IteratorUtils;
 
 import java.util.Collections;
 import java.util.Iterator;
+import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
@@ -40,6 +41,7 @@ import java.util.stream.Collectors;
  */
 public class TinkerEdge extends TinkerElement implements Edge {
 
+    protected final Set<String> edgeLabels;
     protected Map<String, Property> properties;
 
     protected Vertex inVertex = null;
@@ -62,8 +64,30 @@ public class TinkerEdge extends TinkerElement implements Edge {
         }
     }
 
+    protected TinkerEdge(final Object id, final Vertex outVertex, final Set<String> labels, final Vertex inVertex) {
+        this(id, outVertex, labels, inVertex, 0);
+    }
+
+    protected TinkerEdge(final Object id, final Vertex outVertex, final Set<String> labels, final Vertex inVertex, final long currentVersion) {
+        this(id, (AbstractTinkerGraph) outVertex.graph(), outVertex.id(),
+             (labels == null || labels.isEmpty()) ? Edge.DEFAULT_LABEL : labels.iterator().next(),
+             inVertex.id(), currentVersion, false);
+        this.edgeLabels.clear();
+        if (labels != null && !labels.isEmpty()) {
+            this.edgeLabels.addAll(labels);
+        } else {
+            this.edgeLabels.add(Edge.DEFAULT_LABEL);
+        }
+        if (!isTxMode) {
+            this.inVertex = inVertex;
+            this.outVertex = outVertex;
+        }
+    }
+
     private TinkerEdge(final Object id, AbstractTinkerGraph graph, final Object outVertexId, final String label, final Object inVertexId, final long currentVersion, final Boolean skipIndexUpdate) {
         super(id, label, currentVersion);
+        this.edgeLabels = new LinkedHashSet<>();
+        this.edgeLabels.add(label);
         isTxMode = graph instanceof TinkerTransactionGraph;
         this.graph = graph;
         if (isTxMode) {
@@ -107,7 +131,66 @@ public class TinkerEdge extends TinkerElement implements Edge {
 
     @Override
     public Set<String> labels() {
-        return Collections.singleton(this.label);
+        return Collections.unmodifiableSet(this.edgeLabels);
+    }
+
+    @Override
+    @Deprecated
+    public String label() {
+        return this.edgeLabels.iterator().next();
+    }
+
+    @Override
+    public void addLabel(final String label, final String... labels) {
+        graph.touch(this);
+        ElementHelper.validateLabel(label);
+        for (final String l : labels) {
+            ElementHelper.validateLabel(l);
+        }
+        // Remove default label if it was the only label
+        if (this.edgeLabels.size() == 1 && this.edgeLabels.contains(Edge.DEFAULT_LABEL)) {
+            this.graph.removeEdgeFromAdjacency(this, Edge.DEFAULT_LABEL);
+            this.edgeLabels.remove(Edge.DEFAULT_LABEL);
+        }
+        this.edgeLabels.add(label);
+        this.graph.addEdgeToAdjacency(this, label);
+        for (final String l : labels) {
+            this.edgeLabels.add(l);
+            this.graph.addEdgeToAdjacency(this, l);
+        }
+        this.label = this.edgeLabels.iterator().next();
+    }
+
+    @Override
+    public void dropLabels() {
+        graph.touch(this);
+        for (final String l : new LinkedHashSet<>(this.edgeLabels)) {
+            this.graph.removeEdgeFromAdjacency(this, l);
+        }
+        this.edgeLabels.clear();
+        this.edgeLabels.add(Edge.DEFAULT_LABEL);
+        this.graph.addEdgeToAdjacency(this, Edge.DEFAULT_LABEL);
+        this.label = this.edgeLabels.iterator().next();
+    }
+
+    @Override
+    public void dropLabel(final String label, final String... labels) {
+        graph.touch(this);
+        if (this.edgeLabels.contains(label)) {
+            this.graph.removeEdgeFromAdjacency(this, label);
+            this.edgeLabels.remove(label);
+        }
+        for (final String l : labels) {
+            if (this.edgeLabels.contains(l)) {
+                this.graph.removeEdgeFromAdjacency(this, l);
+                this.edgeLabels.remove(l);
+            }
+        }
+        if (this.edgeLabels.isEmpty()) {
+            this.edgeLabels.add(Edge.DEFAULT_LABEL);
+            this.graph.addEdgeToAdjacency(this, Edge.DEFAULT_LABEL);
+        }
+        this.label = this.edgeLabels.iterator().next();
     }
 
     @Override
@@ -129,11 +212,15 @@ public class TinkerEdge extends TinkerElement implements Edge {
         if (!isTxMode) {
             // shallow copy for non-tx mode
             final TinkerEdge edge = new TinkerEdge(id, outVertex, label, inVertex, currentVersion);
+            edge.edgeLabels.clear();
+            edge.edgeLabels.addAll(this.edgeLabels);
             edge.properties = properties;
             return edge;
         }
 
         final TinkerEdge edge = new TinkerEdge(id, graph, outVertexId, label, inVertexId, currentVersion, true);
+        edge.edgeLabels.clear();
+        edge.edgeLabels.addAll(this.edgeLabels);
 
         if (properties != null) {
             final Map<String, Property> cloned = new ConcurrentHashMap<>(properties.size());
diff --git a/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerElement.java b/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerElement.java
index 8aa2d1db03..d8587b71fa 100644
--- a/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerElement.java
+++ b/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerElement.java
@@ -27,7 +27,7 @@ import org.apache.tinkerpop.gremlin.structure.util.ElementHelper;
 public abstract class TinkerElement implements Element {
 
     protected final Object id;
-    protected final String label;
+    protected String label;
     protected boolean removed = false;
     protected long currentVersion;
 
diff --git a/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerGraph.java b/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerGraph.java
index f9b3bc4811..b780b71281 100644
--- a/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerGraph.java
+++ b/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerGraph.java
@@ -303,6 +303,36 @@ public class TinkerGraph extends AbstractTinkerGraph {
         edges.add(edge);
     }
 
+    @Override
+    public void addEdgeToAdjacency(final TinkerEdge edge, final String label) {
+        final TinkerVertex outV = (TinkerVertex) edge.outVertex();
+        final TinkerVertex inV = (TinkerVertex) edge.inVertex();
+        if (null == outV.outEdges) outV.outEdges = new HashMap<>();
+        outV.outEdges.computeIfAbsent(label, k -> new HashSet<>()).add(edge);
+        if (null == inV.inEdges) inV.inEdges = new HashMap<>();
+        inV.inEdges.computeIfAbsent(label, k -> new HashSet<>()).add(edge);
+    }
+
+    @Override
+    public void removeEdgeFromAdjacency(final TinkerEdge edge, final String label) {
+        final TinkerVertex outV = (TinkerVertex) edge.outVertex();
+        final TinkerVertex inV = (TinkerVertex) edge.inVertex();
+        if (outV.outEdges != null) {
+            final Set<Edge> edges = outV.outEdges.get(label);
+            if (edges != null) {
+                edges.remove(edge);
+                if (edges.isEmpty()) outV.outEdges.remove(label);
+            }
+        }
+        if (inV.inEdges != null) {
+            final Set<Edge> edges = inV.inEdges.get(label);
+            if (edges != null) {
+                edges.remove(edge);
+                if (edges.isEmpty()) inV.inEdges.remove(label);
+            }
+        }
+    }
+
     /**
      * Return TinkerGraph feature set.
      * <p/>
diff --git a/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerTransactionGraph.java b/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerTransactionGraph.java
index e6673e4be6..ad1c59a511 100644
--- a/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerTransactionGraph.java
+++ b/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerTransactionGraph.java
@@ -393,6 +393,40 @@ public final class TinkerTransactionGraph extends AbstractTinkerGraph {
         edges.add(edge.id());
     }
 
+    @Override
+    public void addEdgeToAdjacency(final TinkerEdge edge, final String label) {
+        final TinkerVertex outV = (TinkerVertex) edge.outVertex();
+        final TinkerVertex inV = (TinkerVertex) edge.inVertex();
+        touch(outV);
+        touch(inV);
+        if (null == outV.outEdgesId) outV.outEdgesId = new ConcurrentHashMap<>();
+        outV.outEdgesId.computeIfAbsent(label, k -> ConcurrentHashMap.newKeySet()).add(edge.id());
+        if (null == inV.inEdgesId) inV.inEdgesId = new ConcurrentHashMap<>();
+        inV.inEdgesId.computeIfAbsent(label, k -> ConcurrentHashMap.newKeySet()).add(edge.id());
+    }
+
+    @Override
+    public void removeEdgeFromAdjacency(final TinkerEdge edge, final String label) {
+        final TinkerVertex outV = (TinkerVertex) edge.outVertex();
+        final TinkerVertex inV = (TinkerVertex) edge.inVertex();
+        touch(outV);
+        touch(inV);
+        if (outV.outEdgesId != null) {
+            final Set<Object> edges = outV.outEdgesId.get(label);
+            if (edges != null) {
+                edges.remove(edge.id());
+                if (edges.isEmpty()) outV.outEdgesId.remove(label);
+            }
+        }
+        if (inV.inEdgesId != null) {
+            final Set<Object> edges = inV.inEdgesId.get(label);
+            if (edges != null) {
+                edges.remove(edge.id());
+                if (edges.isEmpty()) inV.inEdgesId.remove(label);
+            }
+        }
+    }
+
     /**
      * Return TinkerGraph feature set.
      * <p/>
diff --git a/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerVertex.java b/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerVertex.java
index 67c5ad4692..f3a97beb13 100644
--- a/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerVertex.java
+++ b/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerVertex.java
@@ -61,53 +61,31 @@ public class TinkerVertex extends TinkerElement implements Vertex {
     protected final Set<String> vertexLabels;
 
     protected TinkerVertex(final Object id, final String label, final AbstractTinkerGraph graph) {
-        super(id, label);
-        this.graph = graph;
-        this.isTxMode = graph instanceof TinkerTransactionGraph;
-        this.allowNullPropertyValues = graph.features().vertex().supportsNullPropertyValues();
-        this.vertexLabels = new LinkedHashSet<>();
-        this.vertexLabels.add(null == label ? Vertex.DEFAULT_LABEL : label);
+        this(id, Collections.singleton(label != null ? label : Vertex.DEFAULT_LABEL), graph, -1);
     }
 
     protected TinkerVertex(final Object id, final String label, final AbstractTinkerGraph graph, final long currentVersion) {
-        super(id, label, currentVersion);
-        this.graph = graph;
-        this.isTxMode = graph instanceof TinkerTransactionGraph;
-        this.allowNullPropertyValues = graph.features().vertex().supportsNullPropertyValues();
-        this.vertexLabels = new LinkedHashSet<>();
-        this.vertexLabels.add(null == label ? Vertex.DEFAULT_LABEL : label);
+        this(id, Collections.singleton(label != null ? label : Vertex.DEFAULT_LABEL), graph, currentVersion);
     }
 
     /**
      * Constructs a TinkerVertex with multiple labels.
      */
     protected TinkerVertex(final Object id, final Set<String> labels, final AbstractTinkerGraph graph) {
-        super(id, (labels == null || labels.isEmpty()) ? Vertex.DEFAULT_LABEL : labels.iterator().next());
-        this.graph = graph;
-        this.isTxMode = graph instanceof TinkerTransactionGraph;
-        this.allowNullPropertyValues = graph.features().vertex().supportsNullPropertyValues();
-        if (labels == null || labels.isEmpty()) {
-            this.vertexLabels = new LinkedHashSet<>();
-            this.vertexLabels.add(Vertex.DEFAULT_LABEL);
-        } else {
-            this.vertexLabels = new LinkedHashSet<>(labels);
-        }
+        this(id, labels, graph, -1);
     }
 
     /**
-     * Constructs a TinkerVertex with multiple labels and a specific version (for transactional graphs).
+     * Canonical constructor. Constructs a TinkerVertex with multiple labels and a specific version (for transactional graphs).
      */
     protected TinkerVertex(final Object id, final Set<String> labels, final AbstractTinkerGraph graph, final long currentVersion) {
         super(id, (labels == null || labels.isEmpty()) ? Vertex.DEFAULT_LABEL : labels.iterator().next(), currentVersion);
         this.graph = graph;
         this.isTxMode = graph instanceof TinkerTransactionGraph;
         this.allowNullPropertyValues = graph.features().vertex().supportsNullPropertyValues();
-        if (labels == null || labels.isEmpty()) {
-            this.vertexLabels = new LinkedHashSet<>();
-            this.vertexLabels.add(Vertex.DEFAULT_LABEL);
-        } else {
-            this.vertexLabels = new LinkedHashSet<>(labels);
-        }
+        this.vertexLabels = (labels == null || labels.isEmpty())
+                ? new LinkedHashSet<>(Collections.singleton(Vertex.DEFAULT_LABEL))
+                : new LinkedHashSet<>(labels);
     }
 
     @Override
@@ -135,6 +113,7 @@ public class TinkerVertex extends TinkerElement implements Vertex {
 
         this.vertexLabels.add(label);
         Collections.addAll(this.vertexLabels, labels);
+        this.label = this.vertexLabels.iterator().next();
         this.graph.updateVertexLabelIndex(this);
     }
 
@@ -142,6 +121,7 @@ public class TinkerVertex extends TinkerElement implements Vertex {
     public void dropLabels() {
         this.vertexLabels.clear();
         this.vertexLabels.add(Vertex.DEFAULT_LABEL);
+        this.label = this.vertexLabels.iterator().next();
         this.graph.updateVertexLabelIndex(this);
     }
 
@@ -155,6 +135,7 @@ public class TinkerVertex extends TinkerElement implements Vertex {
         if (this.vertexLabels.isEmpty()) {
             this.vertexLabels.add(Vertex.DEFAULT_LABEL);
         }
+        this.label = this.vertexLabels.iterator().next();
         this.graph.updateVertexLabelIndex(this);
     }
 
@@ -168,9 +149,7 @@ public class TinkerVertex extends TinkerElement implements Vertex {
             return vertex;
         }
 
-        final TinkerVertex vertex = new TinkerVertex(id, label, graph, currentVersion);
-        vertex.vertexLabels.clear();
-        vertex.vertexLabels.addAll(this.vertexLabels);
+        final TinkerVertex vertex = new TinkerVertex(id, new LinkedHashSet<>(vertexLabels), graph, currentVersion);
         if (inEdgesId != null)
             vertex.inEdgesId = CollectionUtil.clone((ConcurrentHashMap<String, Set<Object>>) inEdgesId);
 
diff --git a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/step/sideEffect/LabelMutationStepTest.java b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/step/sideEffect/LabelMutationStepTest.java
index 58ff4fbce1..7ac5c88015 100644
--- a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/step/sideEffect/LabelMutationStepTest.java
+++ b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/step/sideEffect/LabelMutationStepTest.java
@@ -78,12 +78,14 @@ public class LabelMutationStepTest {
         assertThat(v.labels(), containsInAnyOrder("person", "manager"));
     }
 
-    @Test(expected = UnsupportedOperationException.class)
-    public void shouldThrowWhenAddingLabelToEdgeViaTraversal() {
+    @Test
+    public void shouldAddLabelToEdgeViaTraversal() {
         final Vertex v1 = g.addV("person").next();
         final Vertex v2 = g.addV("person").next();
-        v1.addEdge("knows", v2);
+        final Edge e = v1.addEdge("knows", v2);
         g.E().addLabel("friend").iterate();
+        assertThat(e.labels(), hasSize(2));
+        assertThat(e.labels(), containsInAnyOrder("knows", "friend"));
     }
 
     // --- dropLabel step tests ---
@@ -112,12 +114,14 @@ public class LabelMutationStepTest {
         assertThat(v.labels(), containsInAnyOrder("employee"));
     }
 
-    @Test(expected = UnsupportedOperationException.class)
-    public void shouldThrowWhenDroppingLabelsOnEdgeViaTraversal() {
+    @Test
+    public void shouldDropLabelsOnEdgeViaTraversal() {
         final Vertex v1 = g.addV("person").next();
         final Vertex v2 = g.addV("person").next();
-        v1.addEdge("knows", v2);
+        final Edge e = v1.addEdge("knows", v2);
         g.E().dropLabels().iterate();
+        assertThat(e.labels(), hasSize(1));
+        assertThat(e.labels(), containsInAnyOrder(Edge.DEFAULT_LABEL));
     }
 
     // --- addV multi-label tests ---
diff --git a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerVertexMultiLabelTest.java b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerVertexMultiLabelTest.java
index 5fc84f8de2..27387d60e9 100644
--- a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerVertexMultiLabelTest.java
+++ b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerVertexMultiLabelTest.java
@@ -147,20 +147,24 @@ public class TinkerVertexMultiLabelTest {
         assertThat(v.labels(), containsInAnyOrder(Vertex.DEFAULT_LABEL));
     }
 
-    @Test(expected = UnsupportedOperationException.class)
-    public void shouldThrowWhenAddingLabelToEdge() {
+    @Test
+    public void shouldAddLabelToEdge() {
         final Vertex v1 = g.addV("person").next();
         final Vertex v2 = g.addV("person").next();
         final Edge e = v1.addEdge("knows", v2);
         e.addLabel("friend");
+        assertThat(e.labels(), hasSize(2));
+        assertThat(e.labels(), containsInAnyOrder("knows", "friend"));
     }
 
-    @Test(expected = UnsupportedOperationException.class)
-    public void shouldThrowWhenDroppingLabelsOnEdge() {
+    @Test
+    public void shouldDropLabelsOnEdge() {
         final Vertex v1 = g.addV("person").next();
         final Vertex v2 = g.addV("person").next();
         final Edge e = v1.addEdge("knows", v2);
         e.dropLabels();
+        assertThat(e.labels(), hasSize(1));
+        assertThat(e.labels(), containsInAnyOrder(Edge.DEFAULT_LABEL));
     }
 
     @Test


(tinkerpop) 01/06: multilabel prototype

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

xiazcy pushed a commit to branch multi-label-experiment
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git

commit 86b02d945cbe27b603ef02ae74713d4d2cda04aa
Author: Yang Xia <xi...@gmail.com>
AuthorDate: Wed Feb 25 18:25:32 2026 -0800

    multilabel prototype
---
 .../grammar/DefaultGremlinBaseVisitor.java         |  28 +++
 .../language/grammar/TraversalMethodVisitor.java   |  94 ++++++++
 .../grammar/TraversalSourceSpawnMethodVisitor.java |  28 ++-
 .../process/computer/util/ComputerGraph.java       |   5 +
 .../traversal/dsl/graph/GraphTraversal.java        | 112 ++++++++++
 .../traversal/dsl/graph/GraphTraversalSource.java  |  28 +++
 .../gremlin/process/traversal/dsl/graph/__.java    |  49 +++++
 .../process/traversal/step/map/ElementMapStep.java |  39 +++-
 .../process/traversal/step/map/LabelsStep.java     |  53 +++++
 .../traversal/step/map/MergeElementStep.java       |  59 ++++-
 .../traversal/step/map/MergeVertexStep.java        |  28 ++-
 .../traversal/step/map/PropertyMapStep.java        |  23 +-
 .../traversal/step/sideEffect/AddLabelStep.java    | 147 +++++++++++++
 .../traversal/step/sideEffect/DropLabelsStep.java  | 158 +++++++++++++
 .../process/traversal/step/util/HasContainer.java  |   9 +-
 .../process/traversal/step/util/WithOptions.java   |  12 +
 .../tinkerpop/gremlin/structure/Element.java       |  56 +++++
 .../gremlin/structure/VertexProperty.java          |  14 ++
 .../io/binary/types/VertexSerializer.java          |  25 ++-
 .../io/graphson/GraphSONSerializersV4.java         |  22 +-
 .../gremlin/structure/util/ElementHelper.java      |  37 ++++
 .../structure/util/detached/DetachedVertex.java    |  40 ++++
 .../structure/util/reference/ReferenceVertex.java  |  35 +++
 .../gremlin/structure/util/star/StarGraph.java     |   5 +
 gremlin-language/src/main/antlr4/Gremlin.g4        |  30 +++
 .../ser/binary/TypeSerializerFailureTests.java     |   2 +-
 .../tinkergraph/structure/AbstractTinkerGraph.java |  24 ++
 .../gremlin/tinkergraph/structure/TinkerEdge.java  |   5 +
 .../gremlin/tinkergraph/structure/TinkerGraph.java |   5 +-
 .../tinkergraph/structure/TinkerVertex.java        |  78 ++++++-
 .../process/traversal/step/map/LabelsStepTest.java | 106 +++++++++
 .../traversal/step/map/MergeVMultiLabelTest.java   | 154 +++++++++++++
 .../step/sideEffect/LabelMutationPropertyTest.java | 205 +++++++++++++++++
 .../step/sideEffect/LabelMutationStepTest.java     | 245 +++++++++++++++++++++
 .../TinkerVertexMultiLabelGremlinLangTest.java     | 121 ++++++++++
 .../structure/TinkerVertexMultiLabelTest.java      | 191 ++++++++++++++++
 36 files changed, 2236 insertions(+), 36 deletions(-)

diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/DefaultGremlinBaseVisitor.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/DefaultGremlinBaseVisitor.java
index 550774cd27..6a8cb92d8d 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/DefaultGremlinBaseVisitor.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/DefaultGremlinBaseVisitor.java
@@ -183,6 +183,10 @@ public class DefaultGremlinBaseVisitor<T> extends AbstractParseTreeVisitor<T> im
 	 * {@inheritDoc}
 	 */
 	@Override public T visitTraversalMethod_addV_Traversal(final GremlinParser.TraversalMethod_addV_TraversalContext ctx) { notImplemented(ctx); return null; }
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override public T visitTraversalMethod_addV_StringVarargs(final GremlinParser.TraversalMethod_addV_StringVarargsContext ctx) { notImplemented(ctx); return null; }
 	/**
 	 * {@inheritDoc}
 	 */
@@ -539,6 +543,30 @@ public class DefaultGremlinBaseVisitor<T> extends AbstractParseTreeVisitor<T> im
 	 * {@inheritDoc}
 	 */
 	@Override public T visitTraversalMethod_label(final GremlinParser.TraversalMethod_labelContext ctx) { notImplemented(ctx); return null; }
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override public T visitTraversalMethod_labels(final GremlinParser.TraversalMethod_labelsContext ctx) { notImplemented(ctx); return null; }
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override public T visitTraversalMethod_addLabel_String(final GremlinParser.TraversalMethod_addLabel_StringContext ctx) { notImplemented(ctx); return null; }
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override public T visitTraversalMethod_addLabel_Traversal(final GremlinParser.TraversalMethod_addLabel_TraversalContext ctx) { notImplemented(ctx); return null; }
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override public T visitTraversalMethod_dropLabels_Empty(final GremlinParser.TraversalMethod_dropLabels_EmptyContext ctx) { notImplemented(ctx); return null; }
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override public T visitTraversalMethod_dropLabel_String(final GremlinParser.TraversalMethod_dropLabel_StringContext ctx) { notImplemented(ctx); return null; }
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override public T visitTraversalMethod_dropLabel_Traversal(final GremlinParser.TraversalMethod_dropLabel_TraversalContext ctx) { notImplemented(ctx); return null; }
 	/**
 	 * {@inheritDoc}
 	 */
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalMethodVisitor.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalMethodVisitor.java
index 537bdcbe52..b12a20111d 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalMethodVisitor.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalMethodVisitor.java
@@ -34,6 +34,7 @@ import org.apache.tinkerpop.gremlin.structure.T;
 import org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality;
 
 import java.util.Arrays;
+import java.util.List;
 import java.util.Map;
 import java.util.function.BiFunction;
 
@@ -97,6 +98,25 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
         }
     }
 
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public GraphTraversal visitTraversalMethod_addV_StringVarargs(final GremlinParser.TraversalMethod_addV_StringVarargsContext ctx) {
+        final List<GremlinParser.StringArgumentContext> args = ctx.stringArgument();
+        final Object firstLiteralOrVar = antlr.argumentVisitor.visitStringArgument(args.get(0));
+        final String firstLabel = firstLiteralOrVar instanceof String ? (String) firstLiteralOrVar : ((GValue<String>) firstLiteralOrVar).get();
+        final Object secondLiteralOrVar = antlr.argumentVisitor.visitStringArgument(args.get(1));
+        final String secondLabel = secondLiteralOrVar instanceof String ? (String) secondLiteralOrVar : ((GValue<String>) secondLiteralOrVar).get();
+
+        final String[] moreLabels = new String[args.size() - 2];
+        for (int i = 2; i < args.size(); i++) {
+            final Object literalOrVar = antlr.argumentVisitor.visitStringArgument(args.get(i));
+            moreLabels[i - 2] = literalOrVar instanceof String ? (String) literalOrVar : ((GValue<String>) literalOrVar).get();
+        }
+        return this.graphTraversal.addV(firstLabel, secondLabel, moreLabels);
+    }
+
     /**
      * {@inheritDoc}
      */
@@ -978,6 +998,80 @@ public class TraversalMethodVisitor extends TraversalRootVisitor<GraphTraversal>
         return graphTraversal.label();
     }
 
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public GraphTraversal visitTraversalMethod_labels(final GremlinParser.TraversalMethod_labelsContext ctx) {
+        return graphTraversal.labels();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public GraphTraversal visitTraversalMethod_addLabel_String(final GremlinParser.TraversalMethod_addLabel_StringContext ctx) {
+        final List<GremlinParser.StringArgumentContext> args = ctx.stringArgument();
+        final Object firstLiteralOrVar = antlr.argumentVisitor.visitStringArgument(args.get(0));
+        final String firstLabel = firstLiteralOrVar instanceof String ? (String) firstLiteralOrVar : ((GValue<String>) firstLiteralOrVar).get();
+
+        if (args.size() == 1) {
+            return this.graphTraversal.addLabel(firstLabel);
+        } else {
+            final String[] moreLabels = new String[args.size() - 1];
+            for (int i = 1; i < args.size(); i++) {
+                final Object literalOrVar = antlr.argumentVisitor.visitStringArgument(args.get(i));
+                moreLabels[i - 1] = literalOrVar instanceof String ? (String) literalOrVar : ((GValue<String>) literalOrVar).get();
+            }
+            return this.graphTraversal.addLabel(firstLabel, moreLabels);
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public GraphTraversal visitTraversalMethod_addLabel_Traversal(final GremlinParser.TraversalMethod_addLabel_TraversalContext ctx) {
+        return this.graphTraversal.addLabel(antlr.tvisitor.visitNestedTraversal(ctx.nestedTraversal()));
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public GraphTraversal visitTraversalMethod_dropLabels_Empty(final GremlinParser.TraversalMethod_dropLabels_EmptyContext ctx) {
+        return this.graphTraversal.dropLabels();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public GraphTraversal visitTraversalMethod_dropLabel_String(final GremlinParser.TraversalMethod_dropLabel_StringContext ctx) {
+        final List<GremlinParser.StringArgumentContext> args = ctx.stringArgument();
+        final Object firstLiteralOrVar = antlr.argumentVisitor.visitStringArgument(args.get(0));
+        final String firstLabel = firstLiteralOrVar instanceof String ? (String) firstLiteralOrVar : ((GValue<String>) firstLiteralOrVar).get();
+
+        if (args.size() == 1) {
+            return this.graphTraversal.dropLabel(firstLabel);
+        } else {
+            final String[] moreLabels = new String[args.size() - 1];
+            for (int i = 1; i < args.size(); i++) {
+                final Object literalOrVar = antlr.argumentVisitor.visitStringArgument(args.get(i));
+                moreLabels[i - 1] = literalOrVar instanceof String ? (String) literalOrVar : ((GValue<String>) literalOrVar).get();
+            }
+            return this.graphTraversal.dropLabel(firstLabel, moreLabels);
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public GraphTraversal visitTraversalMethod_dropLabel_Traversal(final GremlinParser.TraversalMethod_dropLabel_TraversalContext ctx) {
+        return this.graphTraversal.dropLabel(antlr.tvisitor.visitNestedTraversal(ctx.nestedTraversal()));
+    }
+
     /**
      * {@inheritDoc}
      */
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalSourceSpawnMethodVisitor.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalSourceSpawnMethodVisitor.java
index a57f9cf40b..c2ca344c99 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalSourceSpawnMethodVisitor.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/language/grammar/TraversalSourceSpawnMethodVisitor.java
@@ -22,6 +22,7 @@ import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
 import org.apache.tinkerpop.gremlin.process.traversal.step.GValue;
+import java.util.List;
 import java.util.Map;
 
 /**
@@ -75,12 +76,29 @@ public class TraversalSourceSpawnMethodVisitor extends DefaultGremlinBaseVisitor
      */
     @Override
     public GraphTraversal visitTraversalSourceSpawnMethod_addV(final GremlinParser.TraversalSourceSpawnMethod_addVContext ctx) {
-        if (ctx.stringArgument() != null) {
-            final Object literalOrVar = antlr.argumentVisitor.visitStringArgument(ctx.stringArgument());
-            if (GValue.valueInstanceOf(literalOrVar, String.class)) {
-                return this.traversalSource.addV((GValue<String>) literalOrVar);
+        final List<GremlinParser.StringArgumentContext> stringArgs = ctx.stringArgument();
+        if (stringArgs != null && !stringArgs.isEmpty()) {
+            if (stringArgs.size() == 1) {
+                final Object literalOrVar = antlr.argumentVisitor.visitStringArgument(stringArgs.get(0));
+                if (GValue.valueInstanceOf(literalOrVar, String.class)) {
+                    return this.traversalSource.addV((GValue<String>) literalOrVar);
+                } else {
+                    return this.traversalSource.addV((String) literalOrVar);
+                }
             } else {
-                return this.traversalSource.addV((String) literalOrVar);
+                // Multi-label: addV("a", "b", ...)
+                final Object firstLiteralOrVar = antlr.argumentVisitor.visitStringArgument(stringArgs.get(0));
+                final String firstLabel = firstLiteralOrVar instanceof String ? (String) firstLiteralOrVar : ((GValue<String>) firstLiteralOrVar).get();
+                // Create vertex with first label, then add remaining labels
+                GraphTraversal t = this.traversalSource.addV(firstLabel);
+                final Object secondLiteralOrVar = antlr.argumentVisitor.visitStringArgument(stringArgs.get(1));
+                final String secondLabel = secondLiteralOrVar instanceof String ? (String) secondLiteralOrVar : ((GValue<String>) secondLiteralOrVar).get();
+                final String[] moreLabels = new String[stringArgs.size() - 2];
+                for (int i = 2; i < stringArgs.size(); i++) {
+                    final Object literalOrVar = antlr.argumentVisitor.visitStringArgument(stringArgs.get(i));
+                    moreLabels[i - 2] = literalOrVar instanceof String ? (String) literalOrVar : ((GValue<String>) literalOrVar).get();
+                }
+                return t.addLabel(secondLabel, moreLabels);
             }
         } else if (ctx.nestedTraversal() != null) {
             return this.traversalSource.addV(anonymousVisitor.visitNestedTraversal(ctx.nestedTraversal()));
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/util/ComputerGraph.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/util/ComputerGraph.java
index 3a8a29e743..5634cbbc09 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/util/ComputerGraph.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/computer/util/ComputerGraph.java
@@ -456,6 +456,11 @@ public final class ComputerGraph implements Graph {
             throw GraphComputer.Exceptions.adjacentVertexLabelsCanNotBeRead();
         }
 
+        @Override
+        public Set<String> labels() {
+            throw GraphComputer.Exceptions.adjacentVertexLabelsCanNotBeRead();
+        }
+
         @Override
         public Graph graph() {
             return ComputerGraph.this;
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.java
index c42859f7a5..31c9874af5 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.java
@@ -65,6 +65,8 @@ import org.apache.tinkerpop.gremlin.process.traversal.step.map.MergeVertexStepPl
 import org.apache.tinkerpop.gremlin.process.traversal.step.PropertiesHolder;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.VertexStepPlaceholder;
 import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.AddPropertyStepPlaceholder;
+import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.AddLabelStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.DropLabelsStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.AddEdgeStepContract;
 import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.AddPropertyStepContract;
 import org.apache.tinkerpop.gremlin.process.traversal.step.FromToModulating;
@@ -132,6 +134,7 @@ import org.apache.tinkerpop.gremlin.process.traversal.step.map.IntersectStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.LTrimGlobalStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.LTrimLocalStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.LabelStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.map.LabelsStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.LambdaCollectingBarrierStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.LambdaFlatMapStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.LambdaMapStep;
@@ -350,12 +353,26 @@ public interface GraphTraversal<S, E> extends Traversal<S, E> {
      * @return the traversal with an appended {@link LabelStep}.
      * @see <a href="http://tinkerpop.apache.org/docs/${project.version}/reference/#label-step" target="_blank">Reference Documentation - Label Step</a>
      * @since 3.0.0-incubating
+     * @deprecated As of release 4.0.0, replaced by {@link #labels()}.
      */
+    @Deprecated
     public default GraphTraversal<S, String> label() {
         this.asAdmin().getGremlinLang().addStep(Symbols.label);
         return this.asAdmin().addStep(new LabelStep<>(this.asAdmin()));
     }
 
+    /**
+     * Map the {@link Element} to its labels, emitting each label as a separate traverser.
+     * For vertices with multiple labels, each label is emitted individually.
+     *
+     * @return the traversal with an appended {@link LabelsStep}.
+     * @since 4.0.0
+     */
+    public default GraphTraversal<S, String> labels() {
+        this.asAdmin().getGremlinLang().addStep(Symbols.labels);
+        return this.asAdmin().addStep(new LabelsStep<>(this.asAdmin()));
+    }
+
     /**
      * Map the <code>E</code> object to itself. In other words, a "no op."
      *
@@ -1430,6 +1447,31 @@ public interface GraphTraversal<S, E> extends Traversal<S, E> {
         return this.asAdmin().addStep(new AddVertexStepPlaceholder<>(this.asAdmin(), (String) null));
     }
 
+    /**
+     * Adds a {@link Vertex} with multiple labels. Use this method to create multi-labeled vertices.
+     * Creates the vertex with the first label, then adds the remaining labels.
+     *
+     * @param label1     the first label
+     * @param label2     the second label
+     * @param moreLabels additional labels
+     * @return the traversal with the {@link AddVertexStepContract} added
+     * @since 4.0.0
+     */
+    public default GraphTraversal<S, Vertex> addV(final String label1, final String label2, final String... moreLabels) {
+        if (null == label1) throw new IllegalArgumentException("vertexLabel cannot be null");
+        if (null == label2) throw new IllegalArgumentException("vertexLabel cannot be null");
+        for (final String l : moreLabels) {
+            if (null == l) throw new IllegalArgumentException("vertexLabel cannot be null");
+        }
+        this.asAdmin().getGremlinLang().addStep(Symbols.addV, label1, label2, moreLabels);
+        this.asAdmin().addStep(new AddVertexStepPlaceholder<>(this.asAdmin(), label1));
+        // Add the AddLabelStep directly to avoid double-recording in GremlinLang.
+        // The addV step above already recorded all labels; calling t.addLabel() would
+        // record an additional addLabel() step in GremlinLang, producing incorrect output
+        // like g.addV("a","b").addLabel("b") instead of g.addV("a","b").
+        return this.asAdmin().addStep(new AddLabelStep<>(this.asAdmin(), label2, moreLabels));
+    }
+
     /**
      * Performs a merge (i.e. upsert) style operation for an {@link Vertex} using the incoming {@code Map} traverser as
      * an argument. The {@code Map} represents search criteria and will match each of the supplied key/value pairs where
@@ -3427,6 +3469,72 @@ public interface GraphTraversal<S, E> extends Traversal<S, E> {
         return this.asAdmin().addStep(new DropStep<>(this.asAdmin()));
     }
 
+    /**
+     * Adds one or more labels to the current element. This is a side-effect step that passes the
+     * element through unchanged.
+     *
+     * @param label      the first label to add
+     * @param moreLabels additional labels to add
+     * @return the traversal with an appended {@link AddLabelStep}
+     * @since 4.0.0
+     */
+    public default GraphTraversal<S, E> addLabel(final String label, final String... moreLabels) {
+        this.asAdmin().getGremlinLang().addStep(Symbols.addLabel, label, moreLabels);
+        return this.asAdmin().addStep((AddLabelStep) new AddLabelStep<>(this.asAdmin(), label, moreLabels));
+    }
+
+    /**
+     * Adds dynamically computed labels to the current element. This is a side-effect step that passes the
+     * element through unchanged.
+     *
+     * @param labelTraversal the traversal that produces labels to add
+     * @return the traversal with an appended {@link AddLabelStep}
+     * @since 4.0.0
+     */
+    public default GraphTraversal<S, E> addLabel(final Traversal<?, String> labelTraversal) {
+        this.asAdmin().getGremlinLang().addStep(Symbols.addLabel, labelTraversal);
+        return this.asAdmin().addStep((AddLabelStep) new AddLabelStep(this.asAdmin(), labelTraversal.asAdmin()));
+    }
+
+    /**
+     * Removes all labels from the current element, triggering the provider's default label behavior.
+     * This is a side-effect step that passes the element through unchanged.
+     *
+     * @return the traversal with an appended {@link DropLabelsStep}
+     * @since 4.0.0
+     */
+    public default GraphTraversal<S, E> dropLabels() {
+        this.asAdmin().getGremlinLang().addStep(Symbols.dropLabels);
+        return this.asAdmin().addStep((DropLabelsStep) new DropLabelsStep<>(this.asAdmin()));
+    }
+
+    /**
+     * Removes specific labels from the current element. This is a side-effect step that passes the
+     * element through unchanged.
+     *
+     * @param label      the first label to remove
+     * @param moreLabels additional labels to remove
+     * @return the traversal with an appended {@link DropLabelsStep}
+     * @since 4.0.0
+     */
+    public default GraphTraversal<S, E> dropLabel(final String label, final String... moreLabels) {
+        this.asAdmin().getGremlinLang().addStep(Symbols.dropLabel, label, moreLabels);
+        return this.asAdmin().addStep((DropLabelsStep) new DropLabelsStep<>(this.asAdmin(), label, moreLabels));
+    }
+
+    /**
+     * Removes a dynamically computed label from the current element. This is a side-effect step that passes the
+     * element through unchanged.
+     *
+     * @param labelTraversal the traversal that produces the label to remove
+     * @return the traversal with an appended {@link DropLabelsStep}
+     * @since 4.0.0
+     */
+    public default GraphTraversal<S, E> dropLabel(final Traversal<?, String> labelTraversal) {
+        this.asAdmin().getGremlinLang().addStep(Symbols.dropLabel, labelTraversal);
+        return this.asAdmin().addStep((DropLabelsStep) new DropLabelsStep(this.asAdmin(), labelTraversal.asAdmin()));
+    }
+
     /**
      * Filters <code>E</code> lists given the provided {@code predicate}.
      *
@@ -4724,6 +4832,7 @@ public interface GraphTraversal<S, E> extends Traversal<S, E> {
         public static final String flatMap = "flatMap";
         public static final String id = "id";
         public static final String label = "label";
+        public static final String labels = "labels";
         public static final String identity = "identity";
         public static final String constant = "constant";
         public static final String V = "V";
@@ -4830,6 +4939,9 @@ public interface GraphTraversal<S, E> extends Traversal<S, E> {
         public static final String sample = "sample";
 
         public static final String drop = "drop";
+        public static final String addLabel = "addLabel";
+        public static final String dropLabels = "dropLabels";
+        public static final String dropLabel = "dropLabel";
 
         public static final String sideEffect = "sideEffect";
         public static final String cap = "cap";
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversalSource.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversalSource.java
index 684d9e8609..8777de2d14 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversalSource.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversalSource.java
@@ -31,6 +31,7 @@ import org.apache.tinkerpop.gremlin.process.traversal.step.GValue;
 import org.apache.tinkerpop.gremlin.process.traversal.step.branch.UnionStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.AddEdgeStartStepPlaceholder;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.AddVertexStartStepPlaceholder;
+import org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.AddLabelStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.CallStep;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.CallStepPlaceholder;
 import org.apache.tinkerpop.gremlin.process.traversal.step.map.GraphStep;
@@ -363,6 +364,33 @@ public class GraphTraversalSource implements TraversalSource {
         return traversal.addStep(new AddVertexStartStepPlaceholder(traversal, vertexLabel));
     }
 
+    /**
+     * Spawns a {@link GraphTraversal} by adding a vertex with multiple labels.
+     * Creates the vertex with the first label, then adds the remaining labels.
+     *
+     * @param label1     the first label
+     * @param label2     the second label
+     * @param moreLabels additional labels
+     * @return the traversal with the vertex added
+     * @since 4.0.0
+     */
+    public GraphTraversal<Vertex, Vertex> addV(final String label1, final String label2, final String... moreLabels) {
+        if (null == label1) throw new IllegalArgumentException("vertexLabel cannot be null");
+        if (null == label2) throw new IllegalArgumentException("vertexLabel cannot be null");
+        for (final String l : moreLabels) {
+            if (null == l) throw new IllegalArgumentException("vertexLabel cannot be null");
+        }
+        final GraphTraversalSource clone = this.clone();
+        clone.gremlinLang.addStep(GraphTraversal.Symbols.addV, label1, label2, moreLabels);
+        final GraphTraversal.Admin<Vertex, Vertex> traversal = new DefaultGraphTraversal<>(clone);
+        traversal.addStep(new AddVertexStartStepPlaceholder(traversal, label1));
+        // Add the AddLabelStep directly to avoid double-recording in GremlinLang.
+        // The addV step above already recorded all labels; calling t.addLabel() would
+        // record an additional addLabel() step in GremlinLang, producing incorrect output
+        // like g.addV("a","b").addLabel("b") instead of g.addV("a","b").
+        return traversal.addStep(new AddLabelStep<>(traversal, label2, moreLabels));
+    }
+
     /**
      * Spawns a {@link GraphTraversal} by adding an edge with the specified label.
      *
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/__.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/__.java
index 01986b4534..a9ad25b924 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/__.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/__.java
@@ -126,6 +126,48 @@ public class __ {
         return __.<A>start().label();
     }
 
+    /**
+     * @see GraphTraversal#labels()
+     */
+    public static <A extends Element> GraphTraversal<A, String> labels() {
+        return __.<A>start().labels();
+    }
+
+    /**
+     * @see GraphTraversal#addLabel(String, String...)
+     */
+    public static <A extends Element> GraphTraversal<A, A> addLabel(final String label, final String... moreLabels) {
+        return __.<A>start().addLabel(label, moreLabels);
+    }
+
+    /**
+     * @see GraphTraversal#addLabel(Traversal)
+     */
+    public static <A extends Element> GraphTraversal<A, A> addLabel(final Traversal<?, String> labelTraversal) {
+        return __.<A>start().addLabel(labelTraversal);
+    }
+
+    /**
+     * @see GraphTraversal#dropLabels()
+     */
+    public static <A extends Element> GraphTraversal<A, A> dropLabels() {
+        return __.<A>start().dropLabels();
+    }
+
+    /**
+     * @see GraphTraversal#dropLabel(String, String...)
+     */
+    public static <A extends Element> GraphTraversal<A, A> dropLabel(final String label, final String... moreLabels) {
+        return __.<A>start().dropLabel(label, moreLabels);
+    }
+
+    /**
+     * @see GraphTraversal#dropLabel(Traversal)
+     */
+    public static <A extends Element> GraphTraversal<A, A> dropLabel(final Traversal<?, String> labelTraversal) {
+        return __.<A>start().dropLabel(labelTraversal);
+    }
+
     /**
      * @see GraphTraversal#id()
      */
@@ -654,6 +696,13 @@ public class __ {
         return __.<A>start().addV();
     }
 
+    /**
+     * @see GraphTraversal#addV(String, String, String...)
+     */
+    public static <A> GraphTraversal<A, Vertex> addV(final String label1, final String label2, final String... moreLabels) {
+        return __.<A>start().addV(label1, label2, moreLabels);
+    }
+
     /**
      * @see GraphTraversal#mergeV()
      */
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/ElementMapStep.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/ElementMapStep.java
index 972511a441..370b0cd059 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/ElementMapStep.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/ElementMapStep.java
@@ -20,8 +20,12 @@ package org.apache.tinkerpop.gremlin.process.traversal.step.map;
 
 import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
 import org.apache.tinkerpop.gremlin.process.traversal.Traverser;
+import org.apache.tinkerpop.gremlin.process.traversal.step.Configuring;
 import org.apache.tinkerpop.gremlin.process.traversal.step.GraphComputing;
 import org.apache.tinkerpop.gremlin.process.traversal.step.TraversalParent;
+import org.apache.tinkerpop.gremlin.process.traversal.step.util.Parameters;
+import org.apache.tinkerpop.gremlin.process.traversal.step.util.WithOptions;
+import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.OptionsStrategy;
 import org.apache.tinkerpop.gremlin.process.traversal.traverser.TraverserRequirement;
 import org.apache.tinkerpop.gremlin.structure.Direction;
 import org.apache.tinkerpop.gremlin.structure.Edge;
@@ -46,16 +50,32 @@ import java.util.Set;
  * @author Daniel Kuppitz (http://gremlin.guru)
  * @author Stephen Mallette (http://stephen.genoprime.com)
  */
-public class ElementMapStep<K,E> extends ScalarMapStep<Element, Map<K, E>> implements TraversalParent, GraphComputing {
+public class ElementMapStep<K,E> extends ScalarMapStep<Element, Map<K, E>> implements TraversalParent, GraphComputing, Configuring {
 
     protected final String[] propertyKeys;
     private boolean onGraphComputer = false;
+    private boolean multilabel = false;
+    private final Parameters parameters = new Parameters();
 
     public ElementMapStep(final Traversal.Admin traversal, final String... propertyKeys) {
         super(traversal);
         this.propertyKeys = propertyKeys;
     }
 
+    @Override
+    public void configure(final Object... keyValues) {
+        if (keyValues[0].equals(WithOptions.multilabel)) {
+            this.multilabel = true;
+        } else {
+            this.parameters.set(this, keyValues);
+        }
+    }
+
+    @Override
+    public Parameters getParameters() {
+        return this.parameters;
+    }
+
     @Override
     protected Map<K, E> map(final Traverser.Admin<Element> traverser) {
         final Map<Object, Object> map = new LinkedHashMap<>();
@@ -65,7 +85,11 @@ public class ElementMapStep<K,E> extends ScalarMapStep<Element, Map<K, E>> imple
             map.put(T.key, ((VertexProperty<?>) element).key());
             map.put(T.value, ((VertexProperty<?>) element).value());
         } else {
-            map.put(T.label, element.label());
+            if (isMultilabelEnabled()) {
+                map.put(T.label, element.labels());
+            } else {
+                map.put(T.label, element.label());
+            }
         }
 
         if (element instanceof Edge) {
@@ -102,6 +126,17 @@ public class ElementMapStep<K,E> extends ScalarMapStep<Element, Map<K, E>> imple
         return onGraphComputer;
     }
 
+    /**
+     * Checks if multilabel mode is enabled either via step-level {@code .with(WithOptions.multilabel)}
+     * or source-level {@code g.with("multilabel")}.
+     */
+    private boolean isMultilabelEnabled() {
+        if (this.multilabel) return true;
+        return getTraversal().getStrategies().getStrategy(OptionsStrategy.class)
+                .map(os -> os.getOptions().containsKey("multilabel") || os.getOptions().containsKey(WithOptions.multilabel))
+                .orElse(false);
+    }
+
     public String[] getPropertyKeys() {
         return propertyKeys;
     }
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/LabelsStep.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/LabelsStep.java
new file mode 100644
index 0000000000..a5ba807176
--- /dev/null
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/LabelsStep.java
@@ -0,0 +1,53 @@
+/*
+ * 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 org.apache.tinkerpop.gremlin.process.traversal.step.map;
+
+import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
+import org.apache.tinkerpop.gremlin.process.traversal.Traverser;
+import org.apache.tinkerpop.gremlin.process.traversal.traverser.TraverserRequirement;
+import org.apache.tinkerpop.gremlin.structure.Element;
+import org.apache.tinkerpop.gremlin.structure.util.StringFactory;
+
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Set;
+
+/**
+ * Maps an {@link Element} to its labels, emitting each label as a separate traverser.
+ * For vertices with multiple labels, each label is emitted individually.
+ * For edges, the single label is emitted.
+ *
+ * @since 4.0.0
+ */
+public class LabelsStep<S extends Element> extends FlatMapStep<S, String> {
+
+    public LabelsStep(final Traversal.Admin traversal) {
+        super(traversal);
+    }
+
+    @Override
+    protected Iterator<String> flatMap(final Traverser.Admin<S> traverser) {
+        return traverser.get().labels().iterator();
+    }
+
+    @Override
+    public Set<TraverserRequirement> getRequirements() {
+        return Collections.singleton(TraverserRequirement.OBJECT);
+    }
+}
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/MergeElementStep.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/MergeElementStep.java
index 053213f96c..6b7c261d48 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/MergeElementStep.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/MergeElementStep.java
@@ -254,7 +254,25 @@ public abstract class MergeElementStep<S, E, C> extends FlatMapStep<S, E>
             final Object v = e.getValue();
 
             if (ignoreTokens) {
-                if (!(k instanceof String)) {
+                // Allow T.label in onMatch for multi-label replacement support
+                if (k == T.label) {
+                    if (v instanceof String) {
+                        ElementHelper.validateLabel((String) v);
+                    } else if (v instanceof java.util.Collection) {
+                        for (final Object label : (java.util.Collection<?>) v) {
+                            if (!(label instanceof String)) {
+                                throw new IllegalArgumentException(String.format(
+                                        "option(onMatch) expects T.label collection to contain only Strings - found: %s",
+                                        label.getClass().getSimpleName()));
+                            }
+                            ElementHelper.validateLabel((String) label);
+                        }
+                    } else {
+                        throw new IllegalArgumentException(String.format(
+                                "option(onMatch) expects T.label value to be String or Collection<String> - found: %s",
+                                v.getClass().getSimpleName()));
+                    }
+                } else if (!(k instanceof String)) {
                     throw new IllegalArgumentException(String.format("option(onMatch) expects keys in Map to be of String - check: %s", k));
                 } else {
                     ElementHelper.validateProperty((String) k, v);
@@ -271,12 +289,21 @@ public abstract class MergeElementStep<S, E, C> extends FlatMapStep<S, E>
                             op, allowedTokens, k));
                 }
                 if (k == T.label) {
-                    if (!(v instanceof String)) {
-                        throw new IllegalArgumentException(String.format(
-                                "%s() and option(onCreate) args expect T.label value to be of String - found: %s", op,
-                                v.getClass().getSimpleName()));
-                    } else {
+                    if (v instanceof String) {
                         ElementHelper.validateLabel((String) v);
+                    } else if (v instanceof java.util.Collection) {
+                        for (final Object label : (java.util.Collection<?>) v) {
+                            if (!(label instanceof String)) {
+                                throw new IllegalArgumentException(String.format(
+                                        "%s() expects T.label collection to contain only Strings - found: %s",
+                                        op, label.getClass().getSimpleName()));
+                            }
+                            ElementHelper.validateLabel((String) label);
+                        }
+                    } else {
+                        throw new IllegalArgumentException(String.format(
+                                "%s() and option(onCreate) args expect T.label value to be String or Collection<String> - found: %s",
+                                op, v.getClass().getSimpleName()));
                     }
                 }
                 if (k == Direction.OUT && v instanceof Merge && v != Merge.outV) {
@@ -337,10 +364,10 @@ public abstract class MergeElementStep<S, E, C> extends FlatMapStep<S, E>
 
         final Graph graph = getGraph();
         final Object id = search.get(T.id);
-        final String label = (String) search.get(T.label);
+        final Object labelValue = search.get(T.label);
 
         GraphTraversal t = searchVerticesTraversal(graph, id);
-        t = searchVerticesLabelConstraint(t, label);
+        t = searchVerticesLabelConstraint(t, labelValue);
         t = searchVerticesPropertyConstraints(t, search);
 
         // this should auto-close the underlying traversal
@@ -351,8 +378,20 @@ public abstract class MergeElementStep<S, E, C> extends FlatMapStep<S, E>
         return id != null ? graph.traversal().V(id) : graph.traversal().V();
     }
 
-    protected GraphTraversal searchVerticesLabelConstraint(GraphTraversal t, final String label) {
-        return label != null ? t.hasLabel(label) : t;
+    protected GraphTraversal searchVerticesLabelConstraint(GraphTraversal t, final Object labelValue) {
+        if (labelValue == null) {
+            return t;
+        }
+        if (labelValue instanceof String) {
+            return t.hasLabel((String) labelValue);
+        } else if (labelValue instanceof java.util.Collection) {
+            // Multi-label: AND semantics - must have ALL specified labels
+            for (final Object label : (java.util.Collection<?>) labelValue) {
+                t = t.hasLabel((String) label);
+            }
+            return t;
+        }
+        return t;
     }
 
     protected GraphTraversal searchVerticesPropertyConstraints(GraphTraversal t, final Map search) {
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/MergeVertexStep.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/MergeVertexStep.java
index 118468236f..ad37175cd3 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/MergeVertexStep.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/MergeVertexStep.java
@@ -99,12 +99,32 @@ public class MergeVertexStep<S> extends MergeElementStep<S, Vertex, Map<Object,
                 traverser.set((S) v);
 
                 // assume good input from GraphTraversal - folks might drop in a T here even though it is immutable
-                final Map<String, Object> onMatchMap = materializeMap(traverser, onMatchTraversal);
+                final Map onMatchMap = materializeMap(traverser, onMatchTraversal);
                 validateMapInput(onMatchMap, true);
 
                 onMatchMap.forEach((key, value) -> {
+                    // Handle T.label replacement for multi-label support
+                    if (T.label.equals(key) || T.label.getAccessor().equals(key)) {
+                        // Drop all existing labels and replace with new ones
+                        v.dropLabels();
+                        if (value instanceof String) {
+                            v.addLabel((String) value);
+                        } else if (value instanceof java.util.Collection) {
+                            final java.util.Collection<?> labels = (java.util.Collection<?>) value;
+                            if (!labels.isEmpty()) {
+                                final String[] labelArray = labels.stream()
+                                        .map(l -> (String) l)
+                                        .toArray(String[]::new);
+                                v.addLabel(labelArray[0],
+                                        java.util.Arrays.copyOfRange(labelArray, 1, labelArray.length));
+                            }
+                            // Empty collection = use default label behavior (already handled by dropLabels())
+                        }
+                        return;
+                    }
+
                     Object val = value;
-                    VertexProperty.Cardinality card = graph.features().vertex().getCardinality(key);
+                    VertexProperty.Cardinality card = graph.features().vertex().getCardinality((String) key);
 
                     // a value can be a traversal in the case where the user specifies the cardinality for the value.
                     if (value instanceof CardinalityValueTraversal) {
@@ -115,10 +135,10 @@ public class MergeVertexStep<S> extends MergeElementStep<S, Vertex, Map<Object,
 
                     // trigger callbacks for eventing - in this case, it's a VertexPropertyChangedEvent. if there's no
                     // registry/callbacks then just set the property
-                    EventUtil.registerVertexPropertyChange(callbackRegistry, getTraversal(), v, key, val);
+                    EventUtil.registerVertexPropertyChange(callbackRegistry, getTraversal(), v, (String) key, val);
 
                     // try to detect proper cardinality for the key according to the graph
-                    v.property(card, key, val);
+                    v.property(card, (String) key, val);
                 });
             });
         }
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/PropertyMapStep.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/PropertyMapStep.java
index 489fea8895..25bc143bc3 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/PropertyMapStep.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/PropertyMapStep.java
@@ -25,6 +25,7 @@ import org.apache.tinkerpop.gremlin.process.traversal.step.Configuring;
 import org.apache.tinkerpop.gremlin.process.traversal.step.TraversalParent;
 import org.apache.tinkerpop.gremlin.process.traversal.step.util.Parameters;
 import org.apache.tinkerpop.gremlin.process.traversal.step.util.WithOptions;
+import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.OptionsStrategy;
 import org.apache.tinkerpop.gremlin.process.traversal.traverser.TraverserRequirement;
 import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalProduct;
 import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalUtil;
@@ -58,6 +59,7 @@ public class PropertyMapStep<K,E> extends ScalarMapStep<Element, Map<K, E>>
 
     protected int tokens;
     protected Traversal.Admin<Element, ? extends Property> propertyTraversal;
+    protected boolean multilabel = false;
 
     protected Parameters parameters = new Parameters();
     protected Traversal.Admin<K, E> valueTraversal;
@@ -97,6 +99,8 @@ public class PropertyMapStep<K,E> extends ScalarMapStep<Element, Map<K, E>>
                     this.tokens |= (int) keyValues[i];
                 }
             }
+        } else if (keyValues[0].equals(WithOptions.multilabel)) {
+            this.multilabel = true;
         } else {
             this.parameters.set(this, keyValues);
         }
@@ -200,11 +204,28 @@ public class PropertyMapStep<K,E> extends ScalarMapStep<Element, Map<K, E>>
                 if (includeToken(WithOptions.keys)) map.put(T.key, getVertexPropertyKey((VertexProperty<?>) element));
                 if (includeToken(WithOptions.values)) map.put(T.value, getVertexPropertyValue((VertexProperty<?>) element));
             } else {
-                if (includeToken(WithOptions.labels)) map.put(T.label, getElementLabel(element));
+                if (includeToken(WithOptions.labels)) {
+                    if (isMultilabelEnabled()) {
+                        map.put(T.label, element.labels());
+                    } else {
+                        map.put(T.label, getElementLabel(element));
+                    }
+                }
             }
         }
     }
 
+    /**
+     * Checks if multilabel mode is enabled either via step-level {@code .with(WithOptions.multilabel)}
+     * or source-level {@code g.with("multilabel")}.
+     */
+    private boolean isMultilabelEnabled() {
+        if (this.multilabel) return true;
+        return getTraversal().getStrategies().getStrategy(OptionsStrategy.class)
+                .map(os -> os.getOptions().containsKey("multilabel") || os.getOptions().containsKey(WithOptions.multilabel))
+                .orElse(false);
+    }
+
     protected Object getElementId(Element element){
         return element.id();
     }
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/sideEffect/AddLabelStep.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/sideEffect/AddLabelStep.java
new file mode 100644
index 0000000000..c239623601
--- /dev/null
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/sideEffect/AddLabelStep.java
@@ -0,0 +1,147 @@
+/*
+ * 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 org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect;
+
+import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
+import org.apache.tinkerpop.gremlin.process.traversal.Traverser;
+import org.apache.tinkerpop.gremlin.process.traversal.step.Mutating;
+import org.apache.tinkerpop.gremlin.process.traversal.step.TraversalParent;
+import org.apache.tinkerpop.gremlin.process.traversal.step.util.event.CallbackRegistry;
+import org.apache.tinkerpop.gremlin.process.traversal.step.util.event.Event;
+import org.apache.tinkerpop.gremlin.process.traversal.step.util.event.EventUtil;
+import org.apache.tinkerpop.gremlin.process.traversal.step.util.event.ListCallbackRegistry;
+import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.EventStrategy;
+import org.apache.tinkerpop.gremlin.process.traversal.traverser.TraverserRequirement;
+import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalUtil;
+import org.apache.tinkerpop.gremlin.structure.Element;
+import org.apache.tinkerpop.gremlin.structure.util.ElementHelper;
+import org.apache.tinkerpop.gremlin.structure.util.StringFactory;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+
+/**
+ * Side-effect step that adds labels to the current element by calling {@link Element#addLabel(String, String...)}.
+ * Providers that support label mutation must override {@code addLabel()} in their Element implementations.
+ *
+ * @since 4.0.0
+ */
+public class AddLabelStep<S extends Element> extends SideEffectStep<S>
+        implements Mutating<Event.ElementPropertyChangedEvent>, TraversalParent {
+
+    private final String[] labels;
+    private Traversal.Admin<S, String> labelTraversal;
+    private CallbackRegistry<Event.ElementPropertyChangedEvent> callbackRegistry;
+
+    public AddLabelStep(final Traversal.Admin traversal, final String label, final String... moreLabels) {
+        super(traversal);
+        ElementHelper.validateLabel(label);
+        for (final String l : moreLabels) {
+            ElementHelper.validateLabel(l);
+        }
+        final List<String> allLabels = new ArrayList<>();
+        allLabels.add(label);
+        allLabels.addAll(Arrays.asList(moreLabels));
+        this.labels = allLabels.toArray(new String[0]);
+        this.labelTraversal = null;
+    }
+
+    public AddLabelStep(final Traversal.Admin traversal, final Traversal.Admin<S, String> labelTraversal) {
+        super(traversal);
+        this.labels = null;
+        this.labelTraversal = this.integrateChild(labelTraversal);
+    }
+
+    @Override
+    protected void sideEffect(final Traverser.Admin<S> traverser) {
+        final Element element = traverser.get();
+
+        if (this.labelTraversal != null) {
+            final List<String> collectedLabels = new ArrayList<>();
+            TraversalUtil.applyAll(traverser, this.labelTraversal)
+                    .forEachRemaining(label -> {
+                        ElementHelper.validateLabel(label);
+                        collectedLabels.add(label);
+                    });
+            if (!collectedLabels.isEmpty()) {
+                element.addLabel(collectedLabels.get(0),
+                        collectedLabels.subList(1, collectedLabels.size()).toArray(new String[0]));
+            }
+        } else {
+            element.addLabel(this.labels[0],
+                    Arrays.copyOfRange(this.labels, 1, this.labels.length));
+        }
+
+        // trigger event callbacks
+        final Optional<EventStrategy> optEventStrategy = getTraversal().getStrategies().getStrategy(EventStrategy.class);
+        if (EventUtil.hasAnyCallbacks(callbackRegistry) && optEventStrategy.isPresent()) {
+            final EventStrategy es = optEventStrategy.get();
+            EventUtil.registerPropertyChange(callbackRegistry, es, element, null, null, new Object[0]);
+        }
+    }
+
+    @Override
+    public CallbackRegistry<Event.ElementPropertyChangedEvent> getMutatingCallbackRegistry() {
+        if (null == callbackRegistry) callbackRegistry = new ListCallbackRegistry<>();
+        return callbackRegistry;
+    }
+
+    @Override
+    public Set<TraverserRequirement> getRequirements() {
+        return Collections.singleton(TraverserRequirement.OBJECT);
+    }
+
+    @Override
+    public String toString() {
+        return StringFactory.stepString(this, this.labels != null ? Arrays.asList(this.labels) : this.labelTraversal);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = super.hashCode();
+        if (this.labels != null) result ^= Arrays.hashCode(this.labels);
+        if (this.labelTraversal != null) result ^= this.labelTraversal.hashCode();
+        return result;
+    }
+
+    @Override
+    public List<Traversal.Admin<S, String>> getLocalChildren() {
+        return this.labelTraversal != null ? Collections.singletonList(this.labelTraversal) : Collections.emptyList();
+    }
+
+    @Override
+    public AddLabelStep<S> clone() {
+        final AddLabelStep<S> clone = (AddLabelStep<S>) super.clone();
+        if (this.labelTraversal != null)
+            clone.labelTraversal = this.labelTraversal.clone();
+        return clone;
+    }
+
+    @Override
+    public void setTraversal(final Traversal.Admin<?, ?> parentTraversal) {
+        super.setTraversal(parentTraversal);
+        if (this.labelTraversal != null)
+            this.integrateChild(this.labelTraversal);
+    }
+}
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/sideEffect/DropLabelsStep.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/sideEffect/DropLabelsStep.java
new file mode 100644
index 0000000000..14e5d0634f
--- /dev/null
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/sideEffect/DropLabelsStep.java
@@ -0,0 +1,158 @@
+/*
+ * 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 org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect;
+
+import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
+import org.apache.tinkerpop.gremlin.process.traversal.Traverser;
+import org.apache.tinkerpop.gremlin.process.traversal.step.Mutating;
+import org.apache.tinkerpop.gremlin.process.traversal.step.TraversalParent;
+import org.apache.tinkerpop.gremlin.process.traversal.step.util.event.CallbackRegistry;
+import org.apache.tinkerpop.gremlin.process.traversal.step.util.event.Event;
+import org.apache.tinkerpop.gremlin.process.traversal.step.util.event.EventUtil;
+import org.apache.tinkerpop.gremlin.process.traversal.step.util.event.ListCallbackRegistry;
+import org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.EventStrategy;
+import org.apache.tinkerpop.gremlin.process.traversal.traverser.TraverserRequirement;
+import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalUtil;
+import org.apache.tinkerpop.gremlin.structure.Element;
+import org.apache.tinkerpop.gremlin.structure.util.StringFactory;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+
+/**
+ * Side-effect step that removes labels from the current element by calling
+ * {@link Element#dropLabels()} or {@link Element#dropLabel(String, String...)}.
+ *
+ * @since 4.0.0
+ */
+public class DropLabelsStep<S extends Element> extends SideEffectStep<S>
+        implements Mutating<Event.ElementPropertyChangedEvent>, TraversalParent {
+
+    private final boolean dropAll;
+    private final String[] labels;
+    private Traversal.Admin<S, String> labelTraversal;
+    private CallbackRegistry<Event.ElementPropertyChangedEvent> callbackRegistry;
+
+    /**
+     * Constructor for dropLabels() - removes all labels.
+     */
+    public DropLabelsStep(final Traversal.Admin traversal) {
+        super(traversal);
+        this.dropAll = true;
+        this.labels = null;
+        this.labelTraversal = null;
+    }
+
+    /**
+     * Constructor for dropLabel(String, String...) - removes specific labels.
+     */
+    public DropLabelsStep(final Traversal.Admin traversal, final String label, final String... moreLabels) {
+        super(traversal);
+        this.dropAll = false;
+        final List<String> allLabels = new ArrayList<>();
+        allLabels.add(label);
+        allLabels.addAll(Arrays.asList(moreLabels));
+        this.labels = allLabels.toArray(new String[0]);
+        this.labelTraversal = null;
+    }
+
+    /**
+     * Constructor for dropLabel(Traversal) - removes dynamically computed label.
+     */
+    public DropLabelsStep(final Traversal.Admin traversal, final Traversal.Admin<S, String> labelTraversal) {
+        super(traversal);
+        this.dropAll = false;
+        this.labels = null;
+        this.labelTraversal = this.integrateChild(labelTraversal);
+    }
+
+    @Override
+    protected void sideEffect(final Traverser.Admin<S> traverser) {
+        final Element element = traverser.get();
+
+        if (this.labelTraversal != null) {
+            final String label = TraversalUtil.apply(traverser, this.labelTraversal);
+            if (label != null) {
+                element.dropLabel(label);
+            }
+        } else if (this.dropAll) {
+            element.dropLabels();
+        } else {
+            element.dropLabel(this.labels[0],
+                    Arrays.copyOfRange(this.labels, 1, this.labels.length));
+        }
+
+        // trigger event callbacks
+        final Optional<EventStrategy> optEventStrategy = getTraversal().getStrategies().getStrategy(EventStrategy.class);
+        if (EventUtil.hasAnyCallbacks(callbackRegistry) && optEventStrategy.isPresent()) {
+            final EventStrategy es = optEventStrategy.get();
+            EventUtil.registerPropertyChange(callbackRegistry, es, element, null, null, new Object[0]);
+        }
+    }
+
+    @Override
+    public CallbackRegistry<Event.ElementPropertyChangedEvent> getMutatingCallbackRegistry() {
+        if (null == callbackRegistry) callbackRegistry = new ListCallbackRegistry<>();
+        return callbackRegistry;
+    }
+
+    @Override
+    public Set<TraverserRequirement> getRequirements() {
+        return Collections.singleton(TraverserRequirement.OBJECT);
+    }
+
+    @Override
+    public String toString() {
+        if (this.dropAll) return StringFactory.stepString(this);
+        return StringFactory.stepString(this, this.labels != null ? Arrays.asList(this.labels) : this.labelTraversal);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = super.hashCode();
+        result ^= Boolean.hashCode(this.dropAll);
+        if (this.labels != null) result ^= Arrays.hashCode(this.labels);
+        if (this.labelTraversal != null) result ^= this.labelTraversal.hashCode();
+        return result;
+    }
+
+    @Override
+    public List<Traversal.Admin<S, String>> getLocalChildren() {
+        return this.labelTraversal != null ? Collections.singletonList(this.labelTraversal) : Collections.emptyList();
+    }
+
+    @Override
+    public DropLabelsStep<S> clone() {
+        final DropLabelsStep<S> clone = (DropLabelsStep<S>) super.clone();
+        if (this.labelTraversal != null)
+            clone.labelTraversal = this.labelTraversal.clone();
+        return clone;
+    }
+
+    @Override
+    public void setTraversal(final Traversal.Admin<?, ?> parentTraversal) {
+        super.setTraversal(parentTraversal);
+        if (this.labelTraversal != null)
+            this.integrateChild(this.labelTraversal);
+    }
+}
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/HasContainer.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/HasContainer.java
index 99a9c4e959..a6f7a39d9e 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/HasContainer.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/HasContainer.java
@@ -92,7 +92,14 @@ public class HasContainer implements Serializable, Cloneable, Predicate<Element>
     }
 
     protected boolean testLabel(final Element element) {
-        return this.predicate.test(element.label());
+        // Test against all labels for multi-label support.
+        // For single-label elements this is equivalent to testing element.label().
+        for (final String label : element.labels()) {
+            if (this.predicate.test(label)) {
+                return true;
+            }
+        }
+        return false;
     }
 
     protected boolean testValue(final Property property) {
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/WithOptions.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/WithOptions.java
index a6ea944276..9be8e4f939 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/WithOptions.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/util/WithOptions.java
@@ -90,4 +90,16 @@ public class WithOptions {
      * Index items using a {@code LinkedHashMap}.
      */
     public static int map = 1;
+
+    //
+    // Multi-label configuration
+    //
+
+    /**
+     * Configures multi-label behavior for valueMap and elementMap steps.
+     * When enabled, labels are returned as {@code Set<String>} instead of {@code String}.
+     *
+     * @since 4.0.0
+     */
+    public static final String multilabel = Graph.Hidden.hide("tinkerpop.multilabel");
 }
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/Element.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/Element.java
index f4412123b7..9eee6e6ba0 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/Element.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/Element.java
@@ -44,11 +44,28 @@ public abstract interface Element {
      */
     public Object id();
 
+    /**
+     * Gets all labels for this element.
+     * <p>
+     * For {@link Vertex}: may return zero or more labels (multi-label support).
+     * For {@link Edge}: returns a singleton set (single label only in TinkerGraph).
+     * For {@link VertexProperty}: returns a singleton set containing the property key.
+     *
+     * @return An unmodifiable {@link Set} of labels; may be empty for vertices with no labels
+     * @since 4.0.0
+     */
+    public default Set<String> labels() {
+        return Collections.singleton(label());
+    }
+
     /**
      * Gets the label for the graph {@code Element} which helps categorize it.
      *
      * @return The label of the element
+     * @deprecated As of release 4.0.0, replaced by {@link #labels()}. This method returns an arbitrary label
+     *             when multiple labels exist.
      */
+    @Deprecated
     public String label();
 
     /**
@@ -99,6 +116,41 @@ public abstract interface Element {
      */
     public void remove();
 
+    /**
+     * Adds one or more labels to this element.
+     *
+     * @param label  the first label to add
+     * @param labels additional labels to add
+     * @throws UnsupportedOperationException if the element does not support label mutation
+     * @since 4.0.0
+     */
+    public default void addLabel(final String label, final String... labels) {
+        throw Element.Exceptions.labelMutationNotSupported();
+    }
+
+    /**
+     * Removes all labels from this element, triggering the provider's default label behavior.
+     *
+     * @throws UnsupportedOperationException if the element does not support label mutation
+     * @since 4.0.0
+     */
+    public default void dropLabels() {
+        throw Element.Exceptions.labelMutationNotSupported();
+    }
+
+    /**
+     * Removes specific labels from this element.
+     * If this action removes all labels, triggers the provider's default label behavior.
+     *
+     * @param label  the first label to remove
+     * @param labels additional labels to remove
+     * @throws UnsupportedOperationException if the element does not support label mutation
+     * @since 4.0.0
+     */
+    public default void dropLabel(final String label, final String... labels) {
+        throw Element.Exceptions.labelMutationNotSupported();
+    }
+
 
     /**
      * Get the values of properties as an {@link Iterator}.
@@ -145,5 +197,9 @@ public abstract interface Element {
         public static IllegalArgumentException labelCanNotBeAHiddenKey(final String label) {
             return new IllegalArgumentException("Label can not be a hidden key: " + label);
         }
+
+        public static UnsupportedOperationException labelMutationNotSupported() {
+            return new UnsupportedOperationException("Label mutation is not supported on this element");
+        }
     }
 }
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/VertexProperty.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/VertexProperty.java
index 1bf76b3c54..679b13da7a 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/VertexProperty.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/VertexProperty.java
@@ -21,7 +21,9 @@ package org.apache.tinkerpop.gremlin.structure;
 import org.apache.tinkerpop.gremlin.process.traversal.lambda.CardinalityValueTraversal;
 import org.apache.tinkerpop.gremlin.structure.util.empty.EmptyVertexProperty;
 
+import java.util.Collections;
 import java.util.Iterator;
+import java.util.Set;
 
 /**
  * A {@code VertexProperty} is similar to a {@link Property} in that it denotes a key/value pair associated with an
@@ -78,6 +80,18 @@ public interface VertexProperty<V> extends Property<V>, Element {
         return this.key();
     }
 
+    /**
+     * Returns a singleton set containing the property key, consistent with the single-label
+     * semantics of {@link VertexProperty}.
+     *
+     * @return a singleton {@link Set} containing this property's key
+     * @since 4.0.0
+     */
+    @Override
+    public default Set<String> labels() {
+        return Collections.singleton(this.key());
+    }
+
     /**
      * Constructs an empty {@code VertexProperty}.
      */
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/binary/types/VertexSerializer.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/binary/types/VertexSerializer.java
index 1ab1d82ba0..ce6befecba 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/binary/types/VertexSerializer.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/binary/types/VertexSerializer.java
@@ -29,7 +29,9 @@ import org.apache.tinkerpop.gremlin.structure.util.detached.DetachedVertexProper
 import org.apache.tinkerpop.gremlin.structure.util.reference.ReferenceVertex;
 
 import java.io.IOException;
+import java.util.ArrayList;
 import java.util.Collections;
+import java.util.LinkedHashSet;
 import java.util.List;
 
 /**
@@ -43,11 +45,19 @@ public class VertexSerializer extends SimpleTypeSerializer<Vertex> {
     @Override
     protected Vertex readValue(final Buffer buffer, final GraphBinaryReader context) throws IOException {
         final Object id = context.read(buffer);
-        // reading single string value for now according to GraphBinaryV4
-        final String label = (String) context.readValue(buffer, List.class, false).get(0);
+        // Read labels as List<String> for multi-label support
+        final List<String> labelList = context.readValue(buffer, List.class, false);
         final List<DetachedVertexProperty> properties = context.read(buffer);
 
-        final DetachedVertex.Builder builder = DetachedVertex.build().setId(id).setLabel(label);
+        final DetachedVertex.Builder builder = DetachedVertex.build().setId(id);
+
+        if (labelList != null && !labelList.isEmpty()) {
+            if (labelList.size() == 1) {
+                builder.setLabel(labelList.get(0));
+            } else {
+                builder.setLabels(new LinkedHashSet<>(labelList));
+            }
+        }
 
         if (properties != null) {
             for (final DetachedVertexProperty vp : properties) {
@@ -61,11 +71,12 @@ public class VertexSerializer extends SimpleTypeSerializer<Vertex> {
     @Override
     protected void writeValue(final Vertex value, final Buffer buffer, final GraphBinaryWriter context) throws IOException {
         context.write(value.id(), buffer);
-        // wrapping label into list here for now according to GraphBinaryV4, but we aren't allowing null label yet
-        if (value.label() == null) {
-            throw new IOException("Unexpected null value when nullable is false");
+        // Write all labels as List<String> for multi-label support.
+        final java.util.Set<String> labels = value.labels();
+        if (labels == null || labels.isEmpty()) {
+            throw new IOException("Unexpected null or empty labels when nullable is false");
         }
-        context.writeValue(Collections.singletonList(value.label()), buffer, false);
+        context.writeValue(new ArrayList<>(labels), buffer, false);
         if (value instanceof ReferenceVertex) {
             context.write(null, buffer);
         }
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/GraphSONSerializersV4.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/GraphSONSerializersV4.java
index 66361a0f05..bc1962f8db 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/GraphSONSerializersV4.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/io/graphson/GraphSONSerializersV4.java
@@ -86,7 +86,7 @@ class GraphSONSerializersV4 {
             jsonGenerator.writeStartObject();
 
             jsonGenerator.writeObjectField(GraphSONTokens.ID, vertex.id());
-            writeLabel(jsonGenerator, GraphSONTokens.LABEL, vertex.label());
+            writeLabels(jsonGenerator, GraphSONTokens.LABEL, vertex.labels());
             writeTypeForGraphObjectIfUntyped(jsonGenerator, typeInfo, GraphSONTokens.VERTEX);
             writeProperties(vertex, jsonGenerator, serializerProvider);
 
@@ -395,8 +395,14 @@ class GraphSONSerializersV4 {
                     v.setId(deserializationContext.readValue(jsonParser, Object.class));
                 } else if (jsonParser.getCurrentName().equals(GraphSONTokens.LABEL)) {
                     jsonParser.nextToken();
+                    final java.util.Set<String> labels = new java.util.LinkedHashSet<>();
                     while (jsonParser.nextToken() != JsonToken.END_ARRAY) {
-                        v.setLabel(jsonParser.getText());
+                        labels.add(jsonParser.getText());
+                    }
+                    if (labels.size() == 1) {
+                        v.setLabel(labels.iterator().next());
+                    } else if (!labels.isEmpty()) {
+                        v.setLabels(labels);
                     }
                 } else if (jsonParser.getCurrentName().equals(GraphSONTokens.PROPERTIES)) {
                     jsonParser.nextToken();
@@ -688,4 +694,16 @@ class GraphSONSerializersV4 {
         jsonGenerator.writeString(labelValue);
         jsonGenerator.writeEndArray();
     }
+
+    /**
+     * Helper method for writing multiple labels as an array. Used for multi-label vertex support.
+     */
+    private static void writeLabels(final JsonGenerator jsonGenerator, final String labelName, final java.util.Set<String> labels) throws IOException {
+        jsonGenerator.writeFieldName(labelName);
+        jsonGenerator.writeStartArray();
+        for (final String label : labels) {
+            jsonGenerator.writeString(label);
+        }
+        jsonGenerator.writeEndArray();
+    }
 }
\ No newline at end of file
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/util/ElementHelper.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/util/ElementHelper.java
index 1924e6ef32..7368fe339b 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/util/ElementHelper.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/util/ElementHelper.java
@@ -30,9 +30,11 @@ import org.javatuples.Pair;
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -245,6 +247,41 @@ public final class ElementHelper {
         return Optional.empty();
     }
 
+    /**
+     * Extracts the value of the {@link T#label} key from the list of arguments as a {@link Set} of labels.
+     * Supports both single {@link String} values and {@link java.util.Collection} values for multi-label vertices.
+     *
+     * @param keyValues a list of key/value pairs
+     * @return the labels associated with {@link T#label}, or empty if not present
+     * @since 4.0.0
+     */
+    public static Optional<Set<String>> getLabelsValue(final Object... keyValues) {
+        for (int i = 0; i < keyValues.length; i = i + 2) {
+            if (keyValues[i].equals(T.label)) {
+                final Object labelValue = keyValues[i + 1];
+                if (labelValue instanceof String) {
+                    ElementHelper.validateLabel((String) labelValue);
+                    final Set<String> labels = new LinkedHashSet<>();
+                    labels.add((String) labelValue);
+                    return Optional.of(labels);
+                } else if (labelValue instanceof Collection) {
+                    final Set<String> labels = new LinkedHashSet<>();
+                    for (final Object l : (Collection<?>) labelValue) {
+                        if (!(l instanceof String)) {
+                            throw new IllegalArgumentException("T.label collection must contain only Strings");
+                        }
+                        ElementHelper.validateLabel((String) l);
+                        labels.add((String) l);
+                    }
+                    return Optional.of(labels);
+                } else {
+                    throw new IllegalArgumentException("T.label value must be String or Collection<String>");
+                }
+            }
+        }
+        return Optional.empty();
+    }
+
     /**
      * Assign key/value pairs as properties to an {@link Element}.  If the value of {@link T#id} or
      * {@link T#label} is in the set of pairs, then they are ignored.
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/util/detached/DetachedVertex.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/util/detached/DetachedVertex.java
index c9be9f71da..977eb8ebcc 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/util/detached/DetachedVertex.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/util/detached/DetachedVertex.java
@@ -32,8 +32,10 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Iterator;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * Represents a {@link Vertex} that is disconnected from a {@link Graph}.  "Disconnection" can mean detachment from
@@ -53,11 +55,24 @@ public class DetachedVertex extends DetachedElement<Vertex> implements Vertex {
     private static final String VALUE = "value";
     private static final String PROPERTIES = "properties";
 
+    private Set<String> vertexLabels;
+
     private DetachedVertex() {}
 
     protected DetachedVertex(final Vertex vertex, final boolean withProperties) {
         super(vertex);
 
+        // Capture all labels from the source vertex for multi-label support.
+        // super(vertex) only stores element.label() (single label) in DetachedElement.
+        try {
+            final Set<String> srcLabels = vertex.labels();
+            if (srcLabels.size() > 1) {
+                this.vertexLabels = new LinkedHashSet<>(srcLabels);
+            }
+        } catch (UnsupportedOperationException e) {
+            // Adjacent vertices in graph computer context may not support labels()
+        }
+
         // only serialize properties if requested, and there are meta properties present. this prevents unnecessary
         // object creation of a new HashMap of a new HashMap which will just be empty.  it will use
         // Collections.emptyMap() by default
@@ -99,6 +114,23 @@ public class DetachedVertex extends DetachedElement<Vertex> implements Vertex {
         }
     }
 
+    @Override
+    public Set<String> labels() {
+        if (this.vertexLabels != null) {
+            return Collections.unmodifiableSet(this.vertexLabels);
+        }
+        // Fall back to single label from parent
+        return this.label != null ? Collections.singleton(this.label) : Collections.emptySet();
+    }
+
+    @Override
+    public String label() {
+        if (this.vertexLabels != null && !this.vertexLabels.isEmpty()) {
+            return this.vertexLabels.iterator().next();
+        }
+        return this.label != null ? this.label : Vertex.DEFAULT_LABEL;
+    }
+
     @Override
     public <V> VertexProperty<V> property(final String key, final V value) {
         throw Element.Exceptions.propertyAdditionNotSupported();
@@ -196,6 +228,14 @@ public class DetachedVertex extends DetachedElement<Vertex> implements Vertex {
             return this;
         }
 
+        public Builder setLabels(final Set<String> labels) {
+            v.vertexLabels = labels != null ? new LinkedHashSet<>(labels) : null;
+            if (labels != null && !labels.isEmpty()) {
+                v.label = labels.iterator().next();
+            }
+            return this;
+        }
+
         public DetachedVertex create() {
             return v;
         }
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/util/reference/ReferenceVertex.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/util/reference/ReferenceVertex.java
index ac50c3a6a0..a55cd4b549 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/util/reference/ReferenceVertex.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/util/reference/ReferenceVertex.java
@@ -28,12 +28,16 @@ import org.apache.tinkerpop.gremlin.structure.util.StringFactory;
 
 import java.util.Collections;
 import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.Set;
 
 /**
  * @author Marko A. Rodriguez (http://markorodriguez.com)
  */
 public class ReferenceVertex extends ReferenceElement<Vertex> implements Vertex {
 
+    private Set<String> vertexLabels;
+
     private ReferenceVertex() {
 
     }
@@ -46,8 +50,39 @@ public class ReferenceVertex extends ReferenceElement<Vertex> implements Vertex
         super(id, label);
     }
 
+    public ReferenceVertex(final Object id, final Set<String> labels) {
+        super(id, labels != null && !labels.isEmpty() ? labels.iterator().next() : Vertex.DEFAULT_LABEL);
+        this.vertexLabels = labels != null ? new LinkedHashSet<>(labels) : null;
+    }
+
     public ReferenceVertex(final Vertex vertex) {
         super(vertex);
+        // Capture all labels from the source vertex for multi-label support.
+        // super(vertex) only stores element.label() (single label) in ReferenceElement.
+        try {
+            final Set<String> srcLabels = vertex.labels();
+            if (srcLabels.size() > 1) {
+                this.vertexLabels = new LinkedHashSet<>(srcLabels);
+            }
+        } catch (UnsupportedOperationException e) {
+            // Adjacent vertices in graph computer context may not support labels()
+        }
+    }
+
+    @Override
+    public Set<String> labels() {
+        if (this.vertexLabels != null) {
+            return Collections.unmodifiableSet(this.vertexLabels);
+        }
+        return this.label != null ? Collections.singleton(this.label) : Collections.emptySet();
+    }
+
+    @Override
+    public String label() {
+        if (this.vertexLabels != null && !this.vertexLabels.isEmpty()) {
+            return this.vertexLabels.iterator().next();
+        }
+        return this.label != null ? this.label : Vertex.DEFAULT_LABEL;
     }
 
     @Override
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/util/star/StarGraph.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/util/star/StarGraph.java
index b84d1d36bb..8daaf64aef 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/util/star/StarGraph.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/structure/util/star/StarGraph.java
@@ -732,6 +732,11 @@ public final class StarGraph implements Graph, Serializable {
             throw GraphComputer.Exceptions.adjacentVertexLabelsCanNotBeRead();
         }
 
+        @Override
+        public Set<String> labels() {
+            throw GraphComputer.Exceptions.adjacentVertexLabelsCanNotBeRead();
+        }
+
         @Override
         public Graph graph() {
             return StarGraph.this;
diff --git a/gremlin-language/src/main/antlr4/Gremlin.g4 b/gremlin-language/src/main/antlr4/Gremlin.g4
index 6798ebde55..af76bc0593 100644
--- a/gremlin-language/src/main/antlr4/Gremlin.g4
+++ b/gremlin-language/src/main/antlr4/Gremlin.g4
@@ -118,6 +118,7 @@ traversalSourceSpawnMethod_addE
 traversalSourceSpawnMethod_addV
     : K_ADDV LPAREN RPAREN
     | K_ADDV LPAREN stringArgument RPAREN
+    | K_ADDV LPAREN stringArgument COMMA stringArgument (COMMA stringArgument)* RPAREN
     | K_ADDV LPAREN nestedTraversal RPAREN
     ;
 
@@ -309,6 +310,10 @@ traversalMethod
     | traversalMethod_dateAdd
     | traversalMethod_dateDiff
     | traversalMethod_asNumber
+    | traversalMethod_labels
+    | traversalMethod_addLabel
+    | traversalMethod_dropLabels
+    | traversalMethod_dropLabel
     ;
 
 traversalMethod_V
@@ -327,6 +332,7 @@ traversalMethod_addE
 traversalMethod_addV
     : K_ADDV LPAREN RPAREN #traversalMethod_addV_Empty
     | K_ADDV LPAREN stringArgument RPAREN #traversalMethod_addV_String
+    | K_ADDV LPAREN stringArgument COMMA stringArgument (COMMA stringArgument)* RPAREN #traversalMethod_addV_StringVarargs
     | K_ADDV LPAREN nestedTraversal RPAREN #traversalMethod_addV_Traversal
     ;
 
@@ -622,6 +628,24 @@ traversalMethod_label
     : K_LABEL LPAREN RPAREN
     ;
 
+traversalMethod_labels
+    : K_LABELS LPAREN RPAREN
+    ;
+
+traversalMethod_addLabel
+    : K_ADDLABEL LPAREN stringArgument (COMMA stringArgument)* RPAREN #traversalMethod_addLabel_String
+    | K_ADDLABEL LPAREN nestedTraversal RPAREN #traversalMethod_addLabel_Traversal
+    ;
+
+traversalMethod_dropLabels
+    : K_DROPLABELS LPAREN RPAREN #traversalMethod_dropLabels_Empty
+    ;
+
+traversalMethod_dropLabel
+    : K_DROPLABEL LPAREN stringArgument (COMMA stringArgument)* RPAREN #traversalMethod_dropLabel_String
+    | K_DROPLABEL LPAREN nestedTraversal RPAREN #traversalMethod_dropLabel_Traversal
+    ;
+
 traversalMethod_length
     : K_LENGTH LPAREN RPAREN #traversalMethod_length_Empty
     | K_LENGTH LPAREN traversalScope RPAREN #traversalMethod_length_Scope
@@ -1748,6 +1772,7 @@ keyword
     : TRAVERSAL_ROOT // g - __ is not an allowable key in this context
     | K_ADDALL
     | K_ADDE
+    | K_ADDLABEL
     | K_ADDV
     | K_AGGREGATE
     | K_ALL
@@ -1819,6 +1844,8 @@ keyword
     | K_DOUBLE
     | K_DOUBLEU
     | K_DROP
+    | K_DROPLABEL
+    | K_DROPLABELS
     | K_DT
     | K_DURATION
     | K_DURATIONC
@@ -2060,6 +2087,7 @@ keyword
 
 K_ADDALL: 'addAll';
 K_ADDE: 'addE';
+K_ADDLABEL: 'addLabel';
 K_ADDV: 'addV';
 K_AGGREGATE: 'aggregate';
 K_ALL: 'all';
@@ -2131,6 +2159,8 @@ K_DIV: 'div';
 K_DOUBLE: 'double';
 K_DOUBLEU: 'DOUBLE';
 K_DROP: 'drop';
+K_DROPLABEL: 'dropLabel';
+K_DROPLABELS: 'dropLabels';
 K_DT: 'DT';
 K_DURATION: 'duration';
 K_DURATIONC: 'Duration';
diff --git a/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/binary/TypeSerializerFailureTests.java b/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/binary/TypeSerializerFailureTests.java
index e8573a1763..27529203ca 100644
--- a/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/binary/TypeSerializerFailureTests.java
+++ b/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/binary/TypeSerializerFailureTests.java
@@ -57,7 +57,7 @@ public class TypeSerializerFailureTests {
 
     @Parameterized.Parameters(name = "Value={0}")
     public static Collection input() {
-        final ReferenceVertex vertex = new ReferenceVertex("a vertex", null);
+        final ReferenceVertex vertex = new ReferenceVertex("a vertex", (String) null);
 
         final BulkSet<Object> bulkSet = new BulkSet<>();
         bulkSet.add(vertex, 1L);
diff --git a/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/AbstractTinkerGraph.java b/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/AbstractTinkerGraph.java
index 34ad59357a..cf9f72bd14 100644
--- a/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/AbstractTinkerGraph.java
+++ b/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/AbstractTinkerGraph.java
@@ -292,6 +292,17 @@ public abstract class AbstractTinkerGraph implements Graph {
 
     protected abstract void addInEdge(final TinkerVertex vertex, final String label, final Edge edge);
 
+    /**
+     * Called when a vertex's labels are modified to allow the graph to update any internal label indices.
+     * The default implementation is a no-op since TinkerGraph does not maintain a separate label index.
+     *
+     * @param vertex the vertex whose labels have changed
+     * @since 4.0.0
+     */
+    public void updateVertexLabelIndex(final TinkerVertex vertex) {
+        // no-op by default - TinkerGraph does not maintain a separate label index
+    }
+
     protected TinkerVertex createTinkerVertex(final Object id, final String label, final AbstractTinkerGraph graph) {
         return new TinkerVertex(id, label, graph);
     }
@@ -300,6 +311,19 @@ public abstract class AbstractTinkerGraph implements Graph {
         return new TinkerVertex(id, label, graph, currentVersion);
     }
 
+    /**
+     * Creates a TinkerVertex with multiple labels.
+     *
+     * @param id     the vertex id
+     * @param labels the set of labels for the vertex
+     * @param graph  the graph instance
+     * @return a new TinkerVertex
+     * @since 4.0.0
+     */
+    protected TinkerVertex createTinkerVertex(final Object id, final Set<String> labels, final AbstractTinkerGraph graph) {
+        return new TinkerVertex(id, labels, graph);
+    }
+
     protected TinkerEdge createTinkerEdge(final Object id, final Vertex outVertex, final String label, final Vertex inVertex) {
         return new TinkerEdge(id, outVertex, label, inVertex);
     }
diff --git a/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerEdge.java b/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerEdge.java
index 49bfc7401e..3ced83454e 100644
--- a/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerEdge.java
+++ b/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerEdge.java
@@ -105,6 +105,11 @@ public class TinkerEdge extends TinkerElement implements Edge {
         return null == this.properties ? Collections.emptySet() : this.properties.keySet();
     }
 
+    @Override
+    public Set<String> labels() {
+        return Collections.singleton(this.label);
+    }
+
     @Override
     public void remove() {
         graph.touch(this);
diff --git a/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerGraph.java b/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerGraph.java
index 28f3120e3b..f9b3bc4811 100644
--- a/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerGraph.java
+++ b/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerGraph.java
@@ -135,7 +135,8 @@ public class TinkerGraph extends AbstractTinkerGraph {
     public Vertex addVertex(final Object... keyValues) {
         ElementHelper.legalPropertyKeyValueArray(keyValues);
         Object idValue = vertexIdManager.convert(ElementHelper.getIdValue(keyValues).orElse(null));
-        final String label = ElementHelper.getLabelValue(keyValues).orElse(Vertex.DEFAULT_LABEL);
+        final Set<String> labels = ElementHelper.getLabelsValue(keyValues).orElse(
+                Collections.singleton(Vertex.DEFAULT_LABEL));
 
         if (null != idValue) {
             if (this.vertices.containsKey(idValue))
@@ -144,7 +145,7 @@ public class TinkerGraph extends AbstractTinkerGraph {
             idValue = vertexIdManager.getNextId(this);
         }
 
-        final Vertex vertex = createTinkerVertex(idValue, label, this);
+        final Vertex vertex = createTinkerVertex(idValue, labels, this);
         ElementHelper.attachProperties(vertex, VertexProperty.Cardinality.list, keyValues);
         this.vertices.put(vertex.id(), vertex);
 
diff --git a/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerVertex.java b/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerVertex.java
index c8498b9434..1c7c52802f 100644
--- a/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerVertex.java
+++ b/tinkergraph-gremlin/src/main/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerVertex.java
@@ -31,6 +31,7 @@ import org.apache.tinkerpop.gremlin.util.iterator.IteratorUtils;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Iterator;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -54,11 +55,18 @@ public class TinkerVertex extends TinkerElement implements Vertex {
     private boolean allowNullPropertyValues;
     private final boolean isTxMode;
 
+    /**
+     * Multi-label storage for this vertex. Shadows the single-label field in TinkerElement.
+     */
+    protected final Set<String> vertexLabels;
+
     protected TinkerVertex(final Object id, final String label, final AbstractTinkerGraph graph) {
         super(id, label);
         this.graph = graph;
         this.isTxMode = graph instanceof TinkerTransactionGraph;
         this.allowNullPropertyValues = graph.features().vertex().supportsNullPropertyValues();
+        this.vertexLabels = new LinkedHashSet<>();
+        this.vertexLabels.add(null == label ? Vertex.DEFAULT_LABEL : label);
     }
 
     protected TinkerVertex(final Object id, final String label, final AbstractTinkerGraph graph, final long currentVersion) {
@@ -66,12 +74,78 @@ public class TinkerVertex extends TinkerElement implements Vertex {
         this.graph = graph;
         this.isTxMode = graph instanceof TinkerTransactionGraph;
         this.allowNullPropertyValues = graph.features().vertex().supportsNullPropertyValues();
+        this.vertexLabels = new LinkedHashSet<>();
+        this.vertexLabels.add(null == label ? Vertex.DEFAULT_LABEL : label);
+    }
+
+    /**
+     * Constructs a TinkerVertex with multiple labels.
+     */
+    protected TinkerVertex(final Object id, final Set<String> labels, final AbstractTinkerGraph graph) {
+        super(id, (labels == null || labels.isEmpty()) ? Vertex.DEFAULT_LABEL : labels.iterator().next());
+        this.graph = graph;
+        this.isTxMode = graph instanceof TinkerTransactionGraph;
+        this.allowNullPropertyValues = graph.features().vertex().supportsNullPropertyValues();
+        if (labels == null || labels.isEmpty()) {
+            this.vertexLabels = new LinkedHashSet<>();
+            this.vertexLabels.add(Vertex.DEFAULT_LABEL);
+        } else {
+            this.vertexLabels = new LinkedHashSet<>(labels);
+        }
+    }
+
+    @Override
+    public Set<String> labels() {
+        return Collections.unmodifiableSet(this.vertexLabels);
+    }
+
+    @Override
+    @Deprecated
+    public String label() {
+        return this.vertexLabels.iterator().next();
+    }
+
+    @Override
+    public void addLabel(final String label, final String... labels) {
+        ElementHelper.validateLabel(label);
+        for (final String l : labels) {
+            ElementHelper.validateLabel(l);
+        }
+
+        // Remove default label if it was the only label and we're adding real labels
+        if (this.vertexLabels.size() == 1 && this.vertexLabels.contains(Vertex.DEFAULT_LABEL)) {
+            this.vertexLabels.remove(Vertex.DEFAULT_LABEL);
+        }
+
+        this.vertexLabels.add(label);
+        Collections.addAll(this.vertexLabels, labels);
+        this.graph.updateVertexLabelIndex(this);
+    }
+
+    @Override
+    public void dropLabels() {
+        this.vertexLabels.clear();
+        this.vertexLabels.add(Vertex.DEFAULT_LABEL);
+        this.graph.updateVertexLabelIndex(this);
+    }
+
+    @Override
+    public void dropLabel(final String label, final String... labels) {
+        this.vertexLabels.remove(label);
+        for (final String l : labels) {
+            this.vertexLabels.remove(l);
+        }
+
+        if (this.vertexLabels.isEmpty()) {
+            this.vertexLabels.add(Vertex.DEFAULT_LABEL);
+        }
+        this.graph.updateVertexLabelIndex(this);
     }
 
     @Override
     public Object clone() {
         if (!isTxMode) {
-            final TinkerVertex vertex = new TinkerVertex(id, label, graph, currentVersion);
+            final TinkerVertex vertex = new TinkerVertex(id, new LinkedHashSet<>(vertexLabels), graph);
             vertex.inEdgesId = inEdgesId;
             vertex.outEdgesId = outEdgesId;
             vertex.properties = properties;
@@ -79,6 +153,8 @@ public class TinkerVertex extends TinkerElement implements Vertex {
         }
 
         final TinkerVertex vertex = new TinkerVertex(id, label, graph, currentVersion);
+        vertex.vertexLabels.clear();
+        vertex.vertexLabels.addAll(this.vertexLabels);
         if (inEdgesId != null)
             vertex.inEdgesId = CollectionUtil.clone((ConcurrentHashMap<String, Set<Object>>) inEdgesId);
 
diff --git a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/step/map/LabelsStepTest.java b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/step/map/LabelsStepTest.java
new file mode 100644
index 0000000000..9c816cf9c8
--- /dev/null
+++ b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/step/map/LabelsStepTest.java
@@ -0,0 +1,106 @@
+/*
+ * 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 org.apache.tinkerpop.gremlin.tinkergraph.process.traversal.step.map;
+
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
+import org.apache.tinkerpop.gremlin.structure.Edge;
+import org.apache.tinkerpop.gremlin.structure.Graph;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerGraph;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.containsInAnyOrder;
+import static org.hamcrest.Matchers.hasSize;
+import static org.hamcrest.Matchers.is;
+
+/**
+ * Tests for the labels() traversal step.
+ */
+public class LabelsStepTest {
+
+    private Graph graph;
+    private GraphTraversalSource g;
+
+    @Before
+    public void setup() {
+        graph = TinkerGraph.open();
+        g = graph.traversal();
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        graph.close();
+    }
+
+    @Test
+    public void shouldStreamAllLabelsFromVertex() {
+        final Vertex v = g.addV("person").addLabel("employee").next();
+        final List<String> labels = g.V(v).labels().toList();
+        assertThat(labels, hasSize(2));
+        assertThat(labels, containsInAnyOrder("person", "employee"));
+    }
+
+    @Test
+    public void shouldCountLabelsCorrectly() {
+        final Vertex v = g.addV("person").addLabel("employee").next();
+        final long count = g.V(v).labels().count().next();
+        assertThat(count, is(2L));
+    }
+
+    @Test
+    public void shouldFoldAllLabels() {
+        final Vertex v = g.addV("person").addLabel("employee").next();
+        final List<String> folded = g.V(v).labels().fold().next();
+        assertThat(folded, hasSize(2));
+        assertThat(folded, containsInAnyOrder("person", "employee"));
+    }
+
+    @Test
+    public void shouldReturnSingletonForEdge() {
+        final Vertex v1 = g.addV("person").next();
+        final Vertex v2 = g.addV("person").next();
+        final Edge e = v1.addEdge("knows", v2);
+        final List<String> labels = g.E(e).labels().toList();
+        assertThat(labels, hasSize(1));
+        assertThat(labels, containsInAnyOrder("knows"));
+    }
+
+    @Test
+    public void shouldStreamSingleLabelFromSingleLabelVertex() {
+        final Vertex v = g.addV("person").next();
+        final List<String> labels = g.V(v).labels().toList();
+        assertThat(labels, hasSize(1));
+        assertThat(labels, containsInAnyOrder("person"));
+    }
+
+    @Test
+    public void shouldStreamDefaultLabelFromDefaultVertex() {
+        final Vertex v = g.addV().next();
+        final List<String> labels = g.V(v).labels().toList();
+        assertThat(labels, hasSize(1));
+        assertThat(labels, containsInAnyOrder(Vertex.DEFAULT_LABEL));
+    }
+}
diff --git a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/step/map/MergeVMultiLabelTest.java b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/step/map/MergeVMultiLabelTest.java
new file mode 100644
index 0000000000..2257a15b60
--- /dev/null
+++ b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/step/map/MergeVMultiLabelTest.java
@@ -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 org.apache.tinkerpop.gremlin.tinkergraph.process.traversal.step.map;
+
+import org.apache.tinkerpop.gremlin.process.traversal.Merge;
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
+import org.apache.tinkerpop.gremlin.structure.Graph;
+import org.apache.tinkerpop.gremlin.structure.T;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerGraph;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.containsInAnyOrder;
+import static org.hamcrest.Matchers.hasSize;
+import static org.hamcrest.Matchers.is;
+
+/**
+ * Tests for mergeV() multi-label support.
+ */
+public class MergeVMultiLabelTest {
+
+    private Graph graph;
+    private GraphTraversalSource g;
+
+    @Before
+    public void setup() {
+        graph = TinkerGraph.open();
+        g = graph.traversal();
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        graph.close();
+    }
+
+    // --- mergeV create with multi-label ---
+
+    @Test
+    public void shouldCreateVertexWithMultiLabelViaMergeV() {
+        final Set<String> labels = new LinkedHashSet<>(Arrays.asList("person", "employee"));
+        final Vertex v = g.mergeV(Map.of(T.label, labels, "name", "marko")).next();
+        assertThat(v.labels(), hasSize(2));
+        assertThat(v.labels(), containsInAnyOrder("person", "employee"));
+        assertThat(v.value("name"), is("marko"));
+    }
+
+    @Test
+    public void shouldCreateVertexWithSingleLabelViaMergeV() {
+        final Vertex v = g.mergeV(Map.of(T.label, "person", "name", "marko")).next();
+        assertThat(v.labels(), hasSize(1));
+        assertThat(v.labels(), containsInAnyOrder("person"));
+    }
+
+    @Test
+    public void shouldCreateVertexWithListLabelViaMergeV() {
+        final List<String> labels = Arrays.asList("a", "b", "c");
+        final Vertex v = g.mergeV(Map.of(T.label, labels, "name", "test")).next();
+        assertThat(v.labels(), hasSize(3));
+        assertThat(v.labels(), containsInAnyOrder("a", "b", "c"));
+    }
+
+    // --- mergeV match with multi-label ---
+
+    @Test
+    public void shouldMatchVertexWithMultiLabelViaMergeV() {
+        // create a vertex with two labels
+        final Vertex existing = g.addV("person").addLabel("employee").property("name", "marko").next();
+
+        // mergeV should match it using AND semantics
+        final Set<String> labels = new LinkedHashSet<>(Arrays.asList("person", "employee"));
+        final Vertex matched = g.mergeV(Map.of(T.label, labels, "name", "marko")).next();
+
+        assertThat(matched.id(), is(existing.id()));
+        // should not create a new vertex
+        assertThat(g.V().count().next(), is(1L));
+    }
+
+    @Test
+    public void shouldNotMatchWhenVertexMissingOneLabel() {
+        // create a vertex with only one label
+        g.addV("person").property("name", "marko").next();
+
+        // mergeV with two labels should NOT match (AND semantics)
+        final Set<String> labels = new LinkedHashSet<>(Arrays.asList("person", "employee"));
+        g.mergeV(Map.of(T.label, labels, "name", "marko")).next();
+
+        // should have created a new vertex
+        assertThat(g.V().count().next(), is(2L));
+    }
+
+    // --- mergeV onMatch label replacement ---
+
+    @Test
+    public void shouldReplaceLabelsOnMatchWithSingleLabel() {
+        final Vertex v = g.addV("person").addLabel("employee").property("name", "marko").next();
+
+        g.mergeV(Map.of(T.label, "person", "name", "marko"))
+                .option(Merge.onMatch, Map.of(T.label, "manager")).next();
+
+        // labels should be wholly replaced
+        assertThat(v.labels(), hasSize(1));
+        assertThat(v.labels(), containsInAnyOrder("manager"));
+    }
+
+    @Test
+    public void shouldReplaceLabelsOnMatchWithMultiLabel() {
+        final Vertex v = g.addV("person").property("name", "marko").next();
+
+        final Set<String> newLabels = new LinkedHashSet<>(Arrays.asList("manager", "director"));
+        g.mergeV(Map.of(T.label, "person", "name", "marko"))
+                .option(Merge.onMatch, Map.of(T.label, newLabels)).next();
+
+        assertThat(v.labels(), hasSize(2));
+        assertThat(v.labels(), containsInAnyOrder("manager", "director"));
+    }
+
+    @Test
+    public void shouldApplyDefaultLabelOnMatchWithEmptyCollection() {
+        final Vertex v = g.addV("person").property("name", "marko").next();
+
+        g.mergeV(Map.of(T.label, "person", "name", "marko"))
+                .option(Merge.onMatch, Map.of(T.label, Collections.emptySet())).next();
+
+        // empty collection triggers default label behavior
+        assertThat(v.labels(), hasSize(1));
+        assertThat(v.labels(), containsInAnyOrder(Vertex.DEFAULT_LABEL));
+    }
+}
diff --git a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/step/sideEffect/LabelMutationPropertyTest.java b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/step/sideEffect/LabelMutationPropertyTest.java
new file mode 100644
index 0000000000..5aeea9daa8
--- /dev/null
+++ b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/step/sideEffect/LabelMutationPropertyTest.java
@@ -0,0 +1,205 @@
+/*
+ * 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 org.apache.tinkerpop.gremlin.tinkergraph.process.traversal.step.sideEffect;
+
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
+import org.apache.tinkerpop.gremlin.process.traversal.step.util.WithOptions;
+import org.apache.tinkerpop.gremlin.structure.Graph;
+import org.apache.tinkerpop.gremlin.structure.T;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerGraph;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.Set;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.containsInAnyOrder;
+import static org.hamcrest.Matchers.hasSize;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.Matchers.is;
+
+/**
+ * Property-based tests for addLabel() and dropLabel() traversal steps.
+ * Uses randomized inputs to validate universal correctness properties.
+ */
+public class LabelMutationPropertyTest {
+
+    private static final Logger logger = LoggerFactory.getLogger(LabelMutationPropertyTest.class);
+    private static final int ITERATIONS = 100;
+    private static final String LABEL_CHARS = "abcdefghijklmnopqrstuvwxyz";
+
+    private Graph graph;
+    private GraphTraversalSource g;
+    private Random random;
+
+    @Before
+    public void setup() {
+        graph = TinkerGraph.open();
+        g = graph.traversal();
+        random = new Random(42); // deterministic seed for reproducibility
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        graph.close();
+    }
+
+    private String randomLabel() {
+        final int len = 1 + random.nextInt(8);
+        final StringBuilder sb = new StringBuilder(len);
+        for (int i = 0; i < len; i++) {
+            sb.append(LABEL_CHARS.charAt(random.nextInt(LABEL_CHARS.length())));
+        }
+        return sb.toString();
+    }
+
+    private Set<String> randomLabelSet(final int minSize, final int maxSize) {
+        final int size = minSize + random.nextInt(maxSize - minSize + 1);
+        final Set<String> labels = new HashSet<>();
+        while (labels.size() < size) {
+            labels.add(randomLabel());
+        }
+        return labels;
+    }
+
+    /**
+     * Property 4: AddLabel idempotence.
+     * For any vertex and any label L, if L is already in the vertex's label set,
+     * calling addLabel(L) shall result in the label set being unchanged.
+     */
+    @Test
+    public void shouldBeIdempotentWhenAddingExistingLabel() {
+        for (int i = 0; i < ITERATIONS; i++) {
+            final Set<String> initialLabels = randomLabelSet(1, 5);
+            final Vertex v = g.addV(initialLabels.iterator().next()).next();
+            // add remaining labels
+            for (final String l : initialLabels) {
+                g.V(v).addLabel(l).iterate();
+            }
+
+            // pick a label already present
+            final List<String> labelList = new ArrayList<>(v.labels());
+            final String existingLabel = labelList.get(random.nextInt(labelList.size()));
+            final Set<String> beforeAdd = new HashSet<>(v.labels());
+
+            // add it again - should be idempotent
+            g.V(v).addLabel(existingLabel).iterate();
+            final Set<String> afterAdd = new HashSet<>(v.labels());
+
+            assertThat("Iteration " + i + ": addLabel should be idempotent for label '" + existingLabel + "'",
+                    afterAdd, is(beforeAdd));
+        }
+    }
+
+    /**
+     * Property 6: DropLabels removes all labels and applies default.
+     * For any TinkerVertex with any number of labels, calling dropLabels()
+     * shall result in the vertex having only the default label "vertex".
+     */
+    @Test
+    public void shouldApplyDefaultLabelAfterDroppingAllLabels() {
+        for (int i = 0; i < ITERATIONS; i++) {
+            final Set<String> initialLabels = randomLabelSet(1, 5);
+            final Vertex v = g.addV(initialLabels.iterator().next()).next();
+            for (final String l : initialLabels) {
+                g.V(v).addLabel(l).iterate();
+            }
+
+            // drop all labels
+            g.V(v).dropLabels().iterate();
+
+            assertThat("Iteration " + i + ": after dropLabels(), vertex should have exactly one label",
+                    v.labels(), hasSize(1));
+            assertThat("Iteration " + i + ": after dropLabels(), vertex should have default label",
+                    v.labels(), containsInAnyOrder(Vertex.DEFAULT_LABEL));
+        }
+    }
+
+    /**
+     * Property 8: DropLabel non-existent labels no-op.
+     * For any vertex and any label L not present in the vertex's label set,
+     * calling dropLabel(L) shall leave the label set unchanged.
+     */
+    @Test
+    public void shouldBeNoOpWhenDroppingNonExistentLabel() {
+        for (int i = 0; i < ITERATIONS; i++) {
+            final Set<String> initialLabels = randomLabelSet(1, 5);
+            final Vertex v = g.addV(initialLabels.iterator().next()).next();
+            for (final String l : initialLabels) {
+                g.V(v).addLabel(l).iterate();
+            }
+
+            // generate a label guaranteed not to be in the set
+            String nonExistent = randomLabel();
+            while (v.labels().contains(nonExistent)) {
+                nonExistent = randomLabel();
+            }
+
+            final Set<String> beforeDrop = new HashSet<>(v.labels());
+            g.V(v).dropLabel(nonExistent).iterate();
+            final Set<String> afterDrop = new HashSet<>(v.labels());
+
+            assertThat("Iteration " + i + ": dropLabel of non-existent label '" + nonExistent + "' should be no-op",
+                    afterDrop, is(beforeDrop));
+        }
+    }
+
+    /**
+     * Property 12: ValueMap/ElementMap multilabel configuration.
+     * For any element with labels L, valueMap(true).with(WithOptions.multilabel) shall return
+     * labels as Set&lt;String&gt; equal to L, and without the config shall return a single String from L.
+     */
+    @SuppressWarnings("unchecked")
+    @Test
+    public void shouldReturnCorrectLabelTypeBasedOnMultilabelConfig() {
+        for (int i = 0; i < ITERATIONS; i++) {
+            final Set<String> initialLabels = randomLabelSet(1, 4);
+            final Vertex v = g.addV(initialLabels.iterator().next()).next();
+            for (final String l : initialLabels) {
+                g.V(v).addLabel(l).iterate();
+            }
+
+            // with multilabel config: should return Set<String>
+            final Map<Object, Object> mapWithConfig = g.V(v).valueMap(true)
+                    .with(WithOptions.multilabel).next();
+            final Object labelWithConfig = mapWithConfig.get(T.label);
+            assertThat("Iteration " + i + ": with multilabel config, label should be a Set",
+                    labelWithConfig, instanceOf(Set.class));
+            assertThat("Iteration " + i + ": with multilabel config, labels should match",
+                    (Set<String>) labelWithConfig, is(v.labels()));
+
+            // without multilabel config: should return single String
+            final Map<Object, Object> mapWithoutConfig = g.V(v).valueMap(true).next();
+            final Object labelWithoutConfig = mapWithoutConfig.get(T.label);
+            assertThat("Iteration " + i + ": without multilabel config, label should be a String",
+                    labelWithoutConfig, instanceOf(String.class));
+            assertThat("Iteration " + i + ": without multilabel config, label should be in vertex labels",
+                    v.labels().contains((String) labelWithoutConfig), is(true));
+        }
+    }
+}
diff --git a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/step/sideEffect/LabelMutationStepTest.java b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/step/sideEffect/LabelMutationStepTest.java
new file mode 100644
index 0000000000..58ff4fbce1
--- /dev/null
+++ b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/process/traversal/step/sideEffect/LabelMutationStepTest.java
@@ -0,0 +1,245 @@
+/*
+ * 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 org.apache.tinkerpop.gremlin.tinkergraph.process.traversal.step.sideEffect;
+
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
+import org.apache.tinkerpop.gremlin.process.traversal.step.util.WithOptions;
+import org.apache.tinkerpop.gremlin.structure.Edge;
+import org.apache.tinkerpop.gremlin.structure.Graph;
+import org.apache.tinkerpop.gremlin.structure.T;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerGraph;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import static org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__.constant;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.containsInAnyOrder;
+import static org.hamcrest.Matchers.hasSize;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.Matchers.is;
+
+/**
+ * Tests for addLabel() and dropLabel() traversal steps, addV multi-label,
+ * and valueMap/elementMap multilabel configuration.
+ */
+public class LabelMutationStepTest {
+
+    private Graph graph;
+    private GraphTraversalSource g;
+
+    @Before
+    public void setup() {
+        graph = TinkerGraph.open();
+        g = graph.traversal();
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        graph.close();
+    }
+
+    // --- addLabel step tests ---
+
+    @Test
+    public void shouldAddLabelViaTraversal() {
+        final Vertex v = g.addV("person").next();
+        g.V(v).addLabel("employee").iterate();
+        assertThat(v.labels(), hasSize(2));
+        assertThat(v.labels(), containsInAnyOrder("person", "employee"));
+    }
+
+    @Test
+    public void shouldAddLabelWithConstantTraversal() {
+        final Vertex v = g.addV("person").next();
+        g.V(v).addLabel(constant("manager")).iterate();
+        assertThat(v.labels(), hasSize(2));
+        assertThat(v.labels(), containsInAnyOrder("person", "manager"));
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void shouldThrowWhenAddingLabelToEdgeViaTraversal() {
+        final Vertex v1 = g.addV("person").next();
+        final Vertex v2 = g.addV("person").next();
+        v1.addEdge("knows", v2);
+        g.E().addLabel("friend").iterate();
+    }
+
+    // --- dropLabel step tests ---
+
+    @Test
+    public void shouldDropSpecificLabelViaTraversal() {
+        final Vertex v = g.addV("person").addLabel("employee").next();
+        g.V(v).dropLabel("person").iterate();
+        assertThat(v.labels(), hasSize(1));
+        assertThat(v.labels(), containsInAnyOrder("employee"));
+    }
+
+    @Test
+    public void shouldDropAllLabelsViaTraversal() {
+        final Vertex v = g.addV("person").addLabel("employee").next();
+        g.V(v).dropLabels().iterate();
+        assertThat(v.labels(), hasSize(1));
+        assertThat(v.labels(), containsInAnyOrder(Vertex.DEFAULT_LABEL));
+    }
+
+    @Test
+    public void shouldDropLabelWithConstantTraversal() {
+        final Vertex v = g.addV("person").addLabel("employee").next();
+        g.V(v).dropLabel(constant("person")).iterate();
+        assertThat(v.labels(), hasSize(1));
+        assertThat(v.labels(), containsInAnyOrder("employee"));
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void shouldThrowWhenDroppingLabelsOnEdgeViaTraversal() {
+        final Vertex v1 = g.addV("person").next();
+        final Vertex v2 = g.addV("person").next();
+        v1.addEdge("knows", v2);
+        g.E().dropLabels().iterate();
+    }
+
+    // --- addV multi-label tests ---
+
+    @Test
+    public void shouldCreateVertexWithMultipleLabelsViaAddV() {
+        final Vertex v = g.addV("a").addLabel("b").next();
+        assertThat(v.labels(), hasSize(2));
+        assertThat(v.labels(), containsInAnyOrder("a", "b"));
+    }
+
+    @Test
+    public void shouldCreateVertexWithDefaultLabelViaAddV() {
+        final Vertex v = g.addV().next();
+        assertThat(v.labels(), hasSize(1));
+        assertThat(v.labels(), containsInAnyOrder(Vertex.DEFAULT_LABEL));
+    }
+
+    // --- hasLabel index consistency tests ---
+
+    @Test
+    public void shouldFindVertexByLabelAfterAddLabel() {
+        final Vertex v = g.addV("person").next();
+        g.V(v).addLabel("employee").iterate();
+        final List<Vertex> found = g.V().hasLabel("employee").toList();
+        assertThat(found, hasSize(1));
+        assertThat(found.get(0).id(), is(v.id()));
+    }
+
+    @Test
+    public void shouldNotFindVertexByLabelAfterDropLabel() {
+        final Vertex v = g.addV("person").addLabel("employee").next();
+        g.V(v).dropLabel("employee").iterate();
+        final List<Vertex> found = g.V().hasLabel("employee").toList();
+        assertThat(found, hasSize(0));
+    }
+
+    @Test
+    public void shouldFindVertexByBothLabelsWithChainedHasLabel() {
+        final Vertex v = g.addV("person").addLabel("employee").next();
+        final List<Vertex> found = g.V().hasLabel("person").hasLabel("employee").toList();
+        assertThat(found, hasSize(1));
+        assertThat(found.get(0).id(), is(v.id()));
+    }
+
+    @Test
+    public void shouldNotFindVertexMissingOneOfChainedHasLabels() {
+        final Vertex v = g.addV("person").next();
+        final List<Vertex> found = g.V().hasLabel("person").hasLabel("employee").toList();
+        assertThat(found, hasSize(0));
+    }
+
+    // --- valueMap/elementMap multilabel config tests ---
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void shouldReturnLabelsAsSetWithMultilabelConfig() {
+        final Vertex v = g.addV("person").addLabel("employee").next();
+        final Map<Object, Object> map = g.V(v).valueMap(true)
+                .with(WithOptions.multilabel).next();
+        final Object labelValue = map.get(T.label);
+        assertThat(labelValue, instanceOf(Set.class));
+        final Set<String> labels = (Set<String>) labelValue;
+        assertThat(labels, containsInAnyOrder("person", "employee"));
+    }
+
+    @SuppressWarnings("deprecation")
+    @Test
+    public void shouldReturnLabelAsSingleStringWithoutMultilabelConfig() {
+        final Vertex v = g.addV("person").next();
+        final Map<Object, Object> map = g.V(v).valueMap(true).next();
+        final Object labelValue = map.get(T.label);
+        assertThat(labelValue, instanceOf(String.class));
+        assertThat((String) labelValue, is("person"));
+    }
+
+    // --- addLabel pass-through (chaining) test ---
+
+    @Test
+    public void shouldReturnSameVertexAfterAddLabel() {
+        final Vertex v = g.addV("person").next();
+        final Vertex result = g.V(v).addLabel("employee").next();
+        assertThat(result.id(), is(v.id()));
+        assertThat(result.labels(), containsInAnyOrder("person", "employee"));
+    }
+
+    // --- dropLabel pass-through (chaining) test ---
+
+    @Test
+    public void shouldReturnSameVertexAfterDropLabel() {
+        final Vertex v = g.addV("person").addLabel("employee").next();
+        final Vertex result = g.V(v).dropLabel("employee").next();
+        assertThat(result.id(), is(v.id()));
+    }
+
+    // --- elementMap multilabel config test ---
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void shouldReturnLabelsAsSetWithElementMapMultilabelConfig() {
+        final Vertex v = g.addV("person").addLabel("employee").next();
+        final Map<Object, Object> map = g.V(v).elementMap()
+                .with(WithOptions.multilabel).next();
+        final Object labelValue = map.get(T.label);
+        assertThat(labelValue, instanceOf(Set.class));
+        final Set<String> labels = (Set<String>) labelValue;
+        assertThat(labels, containsInAnyOrder("person", "employee"));
+    }
+
+    // --- GraphTraversalSource multi-label addV test ---
+
+    @Test
+    public void shouldCreateVertexWithMultipleLabelsFromSource() {
+        final Vertex v = g.addV("person", "employee").next();
+        assertThat(v.labels(), hasSize(2));
+        assertThat(v.labels(), containsInAnyOrder("person", "employee"));
+    }
+
+    @Test
+    public void shouldCreateVertexWithThreeLabelsFromSource() {
+        final Vertex v = g.addV("person", "employee", "manager").next();
+        assertThat(v.labels(), hasSize(3));
+        assertThat(v.labels(), containsInAnyOrder("person", "employee", "manager"));
+    }
+}
diff --git a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerVertexMultiLabelGremlinLangTest.java b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerVertexMultiLabelGremlinLangTest.java
new file mode 100644
index 0000000000..99d373bcdd
--- /dev/null
+++ b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerVertexMultiLabelGremlinLangTest.java
@@ -0,0 +1,121 @@
+/*
+ * 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 org.apache.tinkerpop.gremlin.tinkergraph.structure;
+
+import org.apache.tinkerpop.gremlin.process.remote.EmbeddedRemoteConnection;
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
+import org.apache.tinkerpop.gremlin.structure.Graph;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.apache.tinkerpop.gremlin.process.traversal.AnonymousTraversalSource.traversal;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.containsInAnyOrder;
+import static org.hamcrest.Matchers.hasSize;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.not;
+import static org.hamcrest.Matchers.containsString;
+
+/**
+ * Tests that verify GremlinLang output for multi-label addV does not double-record
+ * addLabel steps, and that the EmbeddedRemoteConnection path works correctly.
+ */
+public class TinkerVertexMultiLabelGremlinLangTest {
+
+    private Graph graph;
+    private GraphTraversalSource g;
+
+    @Before
+    public void setup() {
+        graph = TinkerGraph.open();
+        g = graph.traversal();
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        graph.close();
+    }
+
+    @Test
+    public void shouldNotDoubleRecordAddLabelInGremlinLangFromSource() {
+        final GraphTraversal<Vertex, Vertex> t = g.addV("a", "b");
+        final String gremlinLang = t.asAdmin().getGremlinLang().getGremlin();
+        // Should contain addV("a","b") but NOT a trailing addLabel
+        assertThat(gremlinLang, not(containsString("addLabel")));
+    }
+
+    @Test
+    public void shouldNotDoubleRecordAddLabelInGremlinLangFromTraversal() {
+        final GraphTraversal<Vertex, Vertex> t = g.V().addV("a", "b");
+        final String gremlinLang = t.asAdmin().getGremlinLang().getGremlin();
+        // Should contain addV("a","b") but NOT a trailing addLabel
+        assertThat(gremlinLang, not(containsString("addLabel")));
+    }
+
+    @Test
+    public void shouldNotDoubleRecordAddLabelWithThreeLabelsFromSource() {
+        final GraphTraversal<Vertex, Vertex> t = g.addV("a", "b", "c");
+        final String gremlinLang = t.asAdmin().getGremlinLang().getGremlin();
+        assertThat(gremlinLang, not(containsString("addLabel")));
+    }
+
+    @Test
+    public void shouldCreateExactlyOneVertexViaEmbeddedRemoteConnection() throws Exception {
+        final GraphTraversalSource remoteG = traversal().with(new EmbeddedRemoteConnection(g));
+        try {
+            final List<Vertex> vertices = remoteG.addV("a", "b").toList();
+            assertThat(vertices, hasSize(1));
+            assertThat(vertices.get(0).labels(), hasSize(2));
+            assertThat(vertices.get(0).labels(), containsInAnyOrder("a", "b"));
+        } finally {
+            remoteG.close();
+        }
+    }
+
+    @Test
+    public void shouldCreateExactlyOneVertexWithThreeLabelsViaEmbeddedRemote() throws Exception {
+        final GraphTraversalSource remoteG = traversal().with(new EmbeddedRemoteConnection(g));
+        try {
+            final List<Vertex> vertices = remoteG.addV("x", "y", "z").toList();
+            assertThat(vertices, hasSize(1));
+            assertThat(vertices.get(0).labels(), hasSize(3));
+            assertThat(vertices.get(0).labels(), containsInAnyOrder("x", "y", "z"));
+        } finally {
+            remoteG.close();
+        }
+    }
+
+    @Test
+    public void shouldNotDuplicateVerticesOnRepeatedEmbeddedRemoteCalls() throws Exception {
+        final GraphTraversalSource remoteG = traversal().with(new EmbeddedRemoteConnection(g));
+        try {
+            remoteG.addV("a", "b").iterate();
+            remoteG.addV("a", "b").iterate();
+            final long count = g.V().count().next();
+            assertThat(count, is(2L));
+        } finally {
+            remoteG.close();
+        }
+    }
+}
diff --git a/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerVertexMultiLabelTest.java b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerVertexMultiLabelTest.java
new file mode 100644
index 0000000000..5fc84f8de2
--- /dev/null
+++ b/tinkergraph-gremlin/src/test/java/org/apache/tinkerpop/gremlin/tinkergraph/structure/TinkerVertexMultiLabelTest.java
@@ -0,0 +1,191 @@
+/*
+ * 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 org.apache.tinkerpop.gremlin.tinkergraph.structure;
+
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
+import org.apache.tinkerpop.gremlin.structure.Edge;
+import org.apache.tinkerpop.gremlin.structure.Graph;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Set;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.containsInAnyOrder;
+import static org.hamcrest.Matchers.hasSize;
+import static org.hamcrest.Matchers.is;
+
+/**
+ * Tests for multi-label support on TinkerVertex.
+ */
+public class TinkerVertexMultiLabelTest {
+
+    private Graph graph;
+    private GraphTraversalSource g;
+
+    @Before
+    public void setup() {
+        graph = TinkerGraph.open();
+        g = graph.traversal();
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        graph.close();
+    }
+
+    @Test
+    public void shouldCreateVertexWithSingleLabel() {
+        final Vertex v = g.addV("person").next();
+        assertThat(v.labels(), hasSize(1));
+        assertThat(v.labels(), containsInAnyOrder("person"));
+    }
+
+    @Test
+    public void shouldCreateVertexWithMultipleLabels() {
+        final Vertex v = g.addV("person").addLabel("employee").next();
+        assertThat(v.labels(), hasSize(2));
+        assertThat(v.labels(), containsInAnyOrder("person", "employee"));
+    }
+
+    @Test
+    public void shouldCreateVertexWithDefaultLabelWhenNoneSpecified() {
+        final Vertex v = g.addV().next();
+        assertThat(v.labels(), hasSize(1));
+        assertThat(v.labels(), containsInAnyOrder(Vertex.DEFAULT_LABEL));
+    }
+
+    @SuppressWarnings("deprecation")
+    @Test
+    public void shouldReturnFirstLabelFromDeprecatedLabelMethod() {
+        final Vertex v = g.addV("person").next();
+        assertThat(v.label(), is("person"));
+        assertThat(v.labels().contains(v.label()), is(true));
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void shouldReturnUnmodifiableSetFromLabels() {
+        final Vertex v = g.addV("person").next();
+        v.labels().add("hacker");
+    }
+
+    @Test
+    public void shouldAddLabelToExistingVertex() {
+        final Vertex v = g.addV("person").next();
+        v.addLabel("employee");
+        assertThat(v.labels(), hasSize(2));
+        assertThat(v.labels(), containsInAnyOrder("person", "employee"));
+    }
+
+    @Test
+    public void shouldBeIdempotentWhenAddingExistingLabel() {
+        final Vertex v = g.addV("person").next();
+        v.addLabel("person");
+        assertThat(v.labels(), hasSize(1));
+        assertThat(v.labels(), containsInAnyOrder("person"));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void shouldThrowWhenAddingNullLabel() {
+        final Vertex v = g.addV("person").next();
+        v.addLabel(null);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void shouldThrowWhenAddingEmptyLabel() {
+        final Vertex v = g.addV("person").next();
+        v.addLabel("");
+    }
+
+    @Test
+    public void shouldDropAllLabelsAndAssignDefault() {
+        final Vertex v = g.addV("person").addLabel("employee").next();
+        v.dropLabels();
+        assertThat(v.labels(), hasSize(1));
+        assertThat(v.labels(), containsInAnyOrder(Vertex.DEFAULT_LABEL));
+    }
+
+    @Test
+    public void shouldDropSpecificLabel() {
+        final Vertex v = g.addV("person").addLabel("employee").next();
+        v.dropLabel("person");
+        assertThat(v.labels(), hasSize(1));
+        assertThat(v.labels(), containsInAnyOrder("employee"));
+    }
+
+    @Test
+    public void shouldBeNoOpWhenDroppingNonExistentLabel() {
+        final Vertex v = g.addV("person").next();
+        final Set<String> before = Set.copyOf(v.labels());
+        v.dropLabel("nonexistent");
+        assertThat(v.labels(), is(before));
+    }
+
+    @Test
+    public void shouldAssignDefaultWhenDroppingLastSpecificLabel() {
+        final Vertex v = g.addV("person").next();
+        v.dropLabel("person");
+        assertThat(v.labels(), hasSize(1));
+        assertThat(v.labels(), containsInAnyOrder(Vertex.DEFAULT_LABEL));
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void shouldThrowWhenAddingLabelToEdge() {
+        final Vertex v1 = g.addV("person").next();
+        final Vertex v2 = g.addV("person").next();
+        final Edge e = v1.addEdge("knows", v2);
+        e.addLabel("friend");
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void shouldThrowWhenDroppingLabelsOnEdge() {
+        final Vertex v1 = g.addV("person").next();
+        final Vertex v2 = g.addV("person").next();
+        final Edge e = v1.addEdge("knows", v2);
+        e.dropLabels();
+    }
+
+    @Test
+    public void shouldReturnSingletonSetForEdgeLabels() {
+        final Vertex v1 = g.addV("person").next();
+        final Vertex v2 = g.addV("person").next();
+        final Edge e = v1.addEdge("knows", v2);
+        assertThat(e.labels(), hasSize(1));
+        assertThat(e.labels(), containsInAnyOrder("knows"));
+    }
+
+    @Test
+    public void shouldRemoveDefaultLabelWhenAddingFirstRealLabel() {
+        final Vertex v = g.addV().next();
+        assertThat(v.labels(), containsInAnyOrder(Vertex.DEFAULT_LABEL));
+        v.addLabel("person");
+        assertThat(v.labels(), hasSize(1));
+        assertThat(v.labels(), containsInAnyOrder("person"));
+    }
+
+    @Test
+    public void shouldDeduplicateLabelsOnAddV() {
+        final Vertex v = g.addV("person").addLabel("person").next();
+        // addLabel("person") on a vertex already labeled "person" is idempotent
+        assertThat(v.labels(), hasSize(1));
+        assertThat(v.labels(), containsInAnyOrder("person"));
+    }
+}


(tinkerpop) 03/06: Add some feature test

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

xiazcy pushed a commit to branch multi-label-experiment
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git

commit 85df245a2fa0ee4240d58defe197bf1cd06cbd08
Author: Yang Xia <xi...@gmail.com>
AuthorDate: Thu Mar 5 09:38:12 2026 -0800

    Add some feature test
---
 .../gremlin/test/features/map/MergeVertex.feature  | 124 +++++++++++++++++++++
 1 file changed, 124 insertions(+)

diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/MergeVertex.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/MergeVertex.feature
index 801b39db7f..930e3a181b 100644
--- a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/MergeVertex.feature
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/MergeVertex.feature
@@ -990,3 +990,127 @@ Feature: Step - mergeV()
     Then the result should have a count of 1
     And the graph should return 1 for count of "g.V().has(\"person\",\"name\",\"stephen\").hasNot(\"created\")"
     And the graph should return 2 for count of "g.V()"
+
+  @MultiLabel
+  Scenario: g_mergeVXlabel_ab_name_markoX_multilabel_create
+    Given the empty graph
+    And the traversal of
+      """
+      g.mergeV([(T.label): ["person","employee"], name: "marko"])
+      """
+    When iterated to list
+    Then the result should have a count of 1
+    And the graph should return 1 for count of "g.V()"
+    And the graph should return 1 for count of "g.V().hasLabel(\"person\").hasLabel(\"employee\")"
+    And the graph should return 1 for count of "g.V().has(\"name\",\"marko\")"
+
+  @MultiLabel
+  Scenario: g_mergeVXlabel_abc_name_testX_multilabel_create
+    Given the empty graph
+    And the traversal of
+      """
+      g.mergeV([(T.label): ["a","b","c"], name: "test"])
+      """
+    When iterated to list
+    Then the result should have a count of 1
+    And the graph should return 1 for count of "g.V()"
+    And the graph should return 1 for count of "g.V().hasLabel(\"a\").hasLabel(\"b\").hasLabel(\"c\")"
+
+  @MultiLabel
+  Scenario: g_mergeVXlabel_person_name_markoX_single_label
+    Given the empty graph
+    And the traversal of
+      """
+      g.mergeV([(T.label): "person", name: "marko"])
+      """
+    When iterated to list
+    Then the result should have a count of 1
+    And the graph should return 1 for count of "g.V()"
+    And the graph should return 1 for count of "g.V().hasLabel(\"person\")"
+    And the graph should return 1 for count of "g.V().has(\"name\",\"marko\")"
+
+  @MultiLabel
+  Scenario: g_mergeVXlabel_ab_name_markoX_multilabel_match
+    Given the empty graph
+    And the graph initializer of
+      """
+      g.addV("person").addLabel("employee").property("name", "marko")
+      """
+    And the traversal of
+      """
+      g.mergeV([(T.label): ["person","employee"], name: "marko"])
+      """
+    When iterated to list
+    Then the result should have a count of 1
+    And the graph should return 1 for count of "g.V()"
+    And the graph should return 1 for count of "g.V().hasLabel(\"person\").hasLabel(\"employee\")"
+
+  @MultiLabel
+  Scenario: g_mergeVXlabel_ab_name_markoX_multilabel_nomatch
+    Given the empty graph
+    And the graph initializer of
+      """
+      g.addV("person").property("name", "marko")
+      """
+    And the traversal of
+      """
+      g.mergeV([(T.label): ["person","employee"], name: "marko"])
+      """
+    When iterated to list
+    Then the result should have a count of 1
+    And the graph should return 2 for count of "g.V()"
+
+  @MultiLabel
+  Scenario: g_mergeVXlabel_person_name_markoX_optionXonMatch_label_managerX
+    Given the empty graph
+    And the graph initializer of
+      """
+      g.addV("person").addLabel("employee").property("name", "marko")
+      """
+    And the traversal of
+      """
+      g.mergeV([(T.label): "person", name: "marko"]).
+          option(Merge.onMatch, [(T.label): "manager"])
+      """
+    When iterated to list
+    Then the result should have a count of 1
+    And the graph should return 1 for count of "g.V()"
+    And the graph should return 1 for count of "g.V().hasLabel(\"manager\")"
+    And the graph should return 0 for count of "g.V().hasLabel(\"person\")"
+    And the graph should return 0 for count of "g.V().hasLabel(\"employee\")"
+
+  @MultiLabel
+  Scenario: g_mergeVXlabel_person_name_markoX_optionXonMatch_label_manager_directorX
+    Given the empty graph
+    And the graph initializer of
+      """
+      g.addV("person").property("name", "marko")
+      """
+    And the traversal of
+      """
+      g.mergeV([(T.label): "person", name: "marko"]).
+          option(Merge.onMatch, [(T.label): ["manager","director"]])
+      """
+    When iterated to list
+    Then the result should have a count of 1
+    And the graph should return 1 for count of "g.V()"
+    And the graph should return 1 for count of "g.V().hasLabel(\"manager\").hasLabel(\"director\")"
+    And the graph should return 0 for count of "g.V().hasLabel(\"person\")"
+
+  @MultiLabel
+  Scenario: g_mergeVXlabel_person_name_markoX_optionXonMatch_label_emptyX
+    Given the empty graph
+    And the graph initializer of
+      """
+      g.addV("person").property("name", "marko")
+      """
+    And the traversal of
+      """
+      g.mergeV([(T.label): "person", name: "marko"]).
+          option(Merge.onMatch, [(T.label): []])
+      """
+    When iterated to list
+    Then the result should have a count of 1
+    And the graph should return 1 for count of "g.V()"
+    And the graph should return 1 for count of "g.V().hasLabel(\"vertex\")"
+    And the graph should return 0 for count of "g.V().hasLabel(\"person\")"


(tinkerpop) 06/06: GLV implementations

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

xiazcy pushed a commit to branch multi-label-experiment
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git

commit 477473f26f1e4ef598cbbf4ce6be846be648d0f0
Author: Yang Xia <xi...@gmail.com>
AuthorDate: Tue Jun 9 07:58:54 2026 -0700

    GLV implementations
---
 .../Process/Traversal/GraphTraversal.cs            |  94 +++++++++
 .../Process/Traversal/GraphTraversalSource.cs      |  34 ++++
 .../src/Gremlin.Net/Process/Traversal/__.cs        |  72 +++++++
 gremlin-dotnet/src/Gremlin.Net/Structure/Edge.cs   |  14 +-
 .../IO/GraphBinary4/Types/EdgeSerializer.cs        |  29 ++-
 .../IO/GraphBinary4/Types/VertexSerializer.cs      |   9 +-
 gremlin-dotnet/src/Gremlin.Net/Structure/Vertex.cs |  13 +-
 .../Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs |  27 +++
 gremlin-go/driver/anonymousTraversal.go            |  28 +++
 gremlin-go/driver/cucumber/cucumberSteps_test.go   |   1 -
 gremlin-go/driver/cucumber/gremlin.go              |  27 +++
 gremlin-go/driver/graph.go                         |   6 +-
 gremlin-go/driver/graphBinaryDeserializer.go       |  15 +-
 gremlin-go/driver/graphBinarySerializer.go         |  32 ++-
 gremlin-go/driver/graphTraversal.go                |  24 +++
 gremlin-go/driver/graph_test.go                    |   6 +-
 .../lib/process/graph-traversal.ts                 |  44 +++++
 .../gremlin-javascript/lib/structure/graph.ts      |  30 ++-
 .../io/binary/internals/EdgeSerializer.js          |  49 +++--
 .../io/binary/internals/GraphSerializer.js         |  24 ++-
 .../io/binary/internals/VertexSerializer.js        |  16 +-
 .../gremlin-javascript/test/cucumber/gremlin.js    |  27 +++
 gremlin-js/gremlin-mcp/src/translator/stepNames.ts |   8 +
 .../gremlin_python/process/graph_traversal.py      | 119 +++++++++++
 .../main/python/gremlin_python/structure/graph.py  |  26 ++-
 .../gremlin_python/structure/io/graphbinaryV4.py   |  55 ++++--
 .../src/main/python/tests/feature/gremlin.py       |  27 +++
 .../gremlin/language/translator/translations.json  | 217 +++++++++++++++++++++
 .../gremlin/test/features/map/AddEdge.feature      |  34 +++-
 .../gremlin/test/features/map/MergeEdge.feature    |   4 +-
 .../test/features/sideEffect/AddLabel.feature      |  16 ++
 .../test/features/sideEffect/DropLabel.feature     |  32 +++
 .../ser/binary/TypeSerializerFailureTests.java     |   2 +-
 33 files changed, 1080 insertions(+), 81 deletions(-)

diff --git a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GraphTraversal.cs b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GraphTraversal.cs
index de01df3367..2db75a7fd1 100644
--- a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GraphTraversal.cs
+++ b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GraphTraversal.cs
@@ -140,6 +140,21 @@ namespace Gremlin.Net.Process.Traversal
             return Wrap<TStart, Edge>(this);
         }
 
+        /// <summary>
+        ///     Adds the addE step with multiple labels to this <see cref="GraphTraversal{SType, EType}" />.
+        /// </summary>
+        public GraphTraversal<TStart, Edge> AddE (string label1, string label2, params string[] moreLabels)
+        {
+            if (label1 == null) throw new ArgumentNullException(nameof(label1));
+            if (label2 == null) throw new ArgumentNullException(nameof(label2));
+            if (moreLabels == null) throw new ArgumentNullException(nameof(moreLabels));
+
+            var args = new List<object>(2 + moreLabels.Length) { label1, label2 };
+            args.AddRange(moreLabels);
+            GremlinLang.AddStep("addE", args.ToArray());
+            return Wrap<TStart, Edge>(this);
+        }
+
         /// <summary>
         ///     Adds the addV step to this <see cref="GraphTraversal{SType, EType}" />.
         /// </summary>
@@ -167,6 +182,21 @@ namespace Gremlin.Net.Process.Traversal
             return Wrap<TStart, Vertex>(this);
         }
 
+        /// <summary>
+        ///     Adds the addV step with multiple labels to this <see cref="GraphTraversal{SType, EType}" />.
+        /// </summary>
+        public GraphTraversal<TStart, Vertex> AddV (string label1, string label2, params string[] moreLabels)
+        {
+            if (label1 == null) throw new ArgumentNullException(nameof(label1));
+            if (label2 == null) throw new ArgumentNullException(nameof(label2));
+            if (moreLabels == null) throw new ArgumentNullException(nameof(moreLabels));
+
+            var args = new List<object>(2 + moreLabels.Length) { label1, label2 };
+            args.AddRange(moreLabels);
+            GremlinLang.AddStep("addV", args.ToArray());
+            return Wrap<TStart, Vertex>(this);
+        }
+
         /// <summary>
         ///     Adds the aggregate step to this <see cref="GraphTraversal{SType, EType}" />.
         /// </summary>
@@ -1278,6 +1308,70 @@ namespace Gremlin.Net.Process.Traversal
             GremlinLang.AddStep("label");
             return Wrap<TStart, string>(this);
         }
+
+        /// <summary>
+        ///     Adds the labels step to this <see cref="GraphTraversal{SType, EType}" />.
+        /// </summary>
+        public GraphTraversal<TStart, string> Labels ()
+        {
+            GremlinLang.AddStep("labels");
+            return Wrap<TStart, string>(this);
+        }
+
+        /// <summary>
+        ///     Adds the addLabel step to this <see cref="GraphTraversal{SType, EType}" />.
+        /// </summary>
+        public GraphTraversal<TStart, TEnd> AddLabel (string label, params string[] moreLabels)
+        {
+            if (label == null) throw new ArgumentNullException(nameof(label));
+            if (moreLabels == null) throw new ArgumentNullException(nameof(moreLabels));
+
+            var args = new List<object>(1 + moreLabels.Length) { label };
+            args.AddRange(moreLabels);
+            GremlinLang.AddStep("addLabel", args.ToArray());
+            return Wrap<TStart, TEnd>(this);
+        }
+
+        /// <summary>
+        ///     Adds the addLabel step to this <see cref="GraphTraversal{SType, EType}" />.
+        /// </summary>
+        public GraphTraversal<TStart, TEnd> AddLabel (ITraversal labelTraversal)
+        {
+            GremlinLang.AddStep("addLabel", labelTraversal);
+            return Wrap<TStart, TEnd>(this);
+        }
+
+        /// <summary>
+        ///     Adds the dropLabels step to this <see cref="GraphTraversal{SType, EType}" />.
+        /// </summary>
+        public GraphTraversal<TStart, TEnd> DropLabels ()
+        {
+            GremlinLang.AddStep("dropLabels");
+            return Wrap<TStart, TEnd>(this);
+        }
+
+        /// <summary>
+        ///     Adds the dropLabel step to this <see cref="GraphTraversal{SType, EType}" />.
+        /// </summary>
+        public GraphTraversal<TStart, TEnd> DropLabel (string label, params string[] moreLabels)
+        {
+            if (label == null) throw new ArgumentNullException(nameof(label));
+            if (moreLabels == null) throw new ArgumentNullException(nameof(moreLabels));
+
+            var args = new List<object>(1 + moreLabels.Length) { label };
+            args.AddRange(moreLabels);
+            GremlinLang.AddStep("dropLabel", args.ToArray());
+            return Wrap<TStart, TEnd>(this);
+        }
+
+        /// <summary>
+        ///     Adds the dropLabel step to this <see cref="GraphTraversal{SType, EType}" />.
+        /// </summary>
+        public GraphTraversal<TStart, TEnd> DropLabel (ITraversal labelTraversal)
+        {
+            GremlinLang.AddStep("dropLabel", labelTraversal);
+            return Wrap<TStart, TEnd>(this);
+        }
         
         /// <summary>
         ///     Adds the length step to this <see cref="GraphTraversal{SType, EType}" />.
diff --git a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GraphTraversalSource.cs b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GraphTraversalSource.cs
index 581882f490..51d7cb325a 100644
--- a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GraphTraversalSource.cs
+++ b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GraphTraversalSource.cs
@@ -363,6 +363,23 @@ namespace Gremlin.Net.Process.Traversal
             return traversal;
         }
 
+        /// <summary>
+        ///     Spawns a <see cref="GraphTraversal{SType, EType}" /> off this graph traversal source and adds the addE step
+        ///     with multiple labels to that traversal.
+        /// </summary>
+        public GraphTraversal<Edge, Edge> AddE(string label1, string label2, params string[] moreLabels)
+        {
+            if (label1 == null) throw new ArgumentNullException(nameof(label1));
+            if (label2 == null) throw new ArgumentNullException(nameof(label2));
+            if (moreLabels == null) throw new ArgumentNullException(nameof(moreLabels));
+
+            var traversal = new GraphTraversal<Edge, Edge>(TraversalStrategies, GremlinLang.Clone());
+            var args = new List<object>(2 + moreLabels.Length) { label1, label2 };
+            args.AddRange(moreLabels);
+            traversal.GremlinLang.AddStep("addE", args.ToArray());
+            return traversal;
+        }
+
         /// <summary>
         ///     Spawns a <see cref="GraphTraversal{SType, EType}" /> off this graph traversal source and adds the mergeE step to that
         ///     traversal.
@@ -424,6 +441,23 @@ namespace Gremlin.Net.Process.Traversal
             return traversal;
         }
 
+        /// <summary>
+        ///     Spawns a <see cref="GraphTraversal{SType, EType}" /> off this graph traversal source and adds the addV step
+        ///     with multiple labels to that traversal.
+        /// </summary>
+        public GraphTraversal<Vertex, Vertex> AddV(string label1, string label2, params string[] moreLabels)
+        {
+            if (label1 == null) throw new ArgumentNullException(nameof(label1));
+            if (label2 == null) throw new ArgumentNullException(nameof(label2));
+            if (moreLabels == null) throw new ArgumentNullException(nameof(moreLabels));
+
+            var traversal = new GraphTraversal<Vertex, Vertex>(TraversalStrategies, GremlinLang.Clone());
+            var args = new List<object>(2 + moreLabels.Length) { label1, label2 };
+            args.AddRange(moreLabels);
+            traversal.GremlinLang.AddStep("addV", args.ToArray());
+            return traversal;
+        }
+
         /// <summary>
         ///     Spawns a <see cref="GraphTraversal{SType, EType}" /> off this graph traversal source and adds the mergeV step to that
         ///     traversal.
diff --git a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/__.cs b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/__.cs
index b16732a61b..f8c76187d1 100644
--- a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/__.cs
+++ b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/__.cs
@@ -76,6 +76,16 @@ namespace Gremlin.Net.Process.Traversal
             return new GraphTraversal<object, Edge>().AddE(edgeLabelTraversal);            
         }
 
+        /// <summary>
+        ///     Spawns a <see cref="GraphTraversal{SType, EType}" /> and adds the addE step with multiple labels to that traversal.
+        /// </summary>
+        public static GraphTraversal<object, Edge> AddE(string label1, string label2, params string[] moreLabels)
+        {
+            return moreLabels is { Length: 0 }
+                ? new GraphTraversal<object, Edge>().AddE(label1, label2)
+                : new GraphTraversal<object, Edge>().AddE(label1, label2, moreLabels);            
+        }
+
         /// <summary>
         ///     Spawns a <see cref="GraphTraversal{SType, EType}" /> and adds the addV step to that traversal.
         /// </summary>
@@ -100,6 +110,16 @@ namespace Gremlin.Net.Process.Traversal
             return new GraphTraversal<object, Vertex>().AddV(vertexLabelTraversal);            
         }
 
+        /// <summary>
+        ///     Spawns a <see cref="GraphTraversal{SType, EType}" /> and adds the addV step with multiple labels to that traversal.
+        /// </summary>
+        public static GraphTraversal<object, Vertex> AddV(string label1, string label2, params string[] moreLabels)
+        {
+            return moreLabels is { Length: 0 }
+                ? new GraphTraversal<object, Vertex>().AddV(label1, label2)
+                : new GraphTraversal<object, Vertex>().AddV(label1, label2, moreLabels);            
+        }
+
         /// <summary>
         ///     Spawns a <see cref="GraphTraversal{SType, EType}" /> and adds the aggregate step to that traversal.
         /// </summary>
@@ -893,6 +913,58 @@ namespace Gremlin.Net.Process.Traversal
         {
             return new GraphTraversal<object, string>().Label();            
         }
+
+        /// <summary>
+        ///     Spawns a <see cref="GraphTraversal{SType, EType}" /> and adds the labels step to that traversal.
+        /// </summary>
+        public static GraphTraversal<object, string> Labels()
+        {
+            return new GraphTraversal<object, string>().Labels();            
+        }
+
+        /// <summary>
+        ///     Spawns a <see cref="GraphTraversal{SType, EType}" /> and adds the addLabel step to that traversal.
+        /// </summary>
+        public static GraphTraversal<object, object> AddLabel(string label, params string[] moreLabels)
+        {
+            return moreLabels is { Length: 0 }
+                ? new GraphTraversal<object, object>().AddLabel(label)
+                : new GraphTraversal<object, object>().AddLabel(label, moreLabels);            
+        }
+
+        /// <summary>
+        ///     Spawns a <see cref="GraphTraversal{SType, EType}" /> and adds the addLabel step to that traversal.
+        /// </summary>
+        public static GraphTraversal<object, object> AddLabel(ITraversal labelTraversal)
+        {
+            return new GraphTraversal<object, object>().AddLabel(labelTraversal);            
+        }
+
+        /// <summary>
+        ///     Spawns a <see cref="GraphTraversal{SType, EType}" /> and adds the dropLabels step to that traversal.
+        /// </summary>
+        public static GraphTraversal<object, object> DropLabels()
+        {
+            return new GraphTraversal<object, object>().DropLabels();            
+        }
+
+        /// <summary>
+        ///     Spawns a <see cref="GraphTraversal{SType, EType}" /> and adds the dropLabel step to that traversal.
+        /// </summary>
+        public static GraphTraversal<object, object> DropLabel(string label, params string[] moreLabels)
+        {
+            return moreLabels is { Length: 0 }
+                ? new GraphTraversal<object, object>().DropLabel(label)
+                : new GraphTraversal<object, object>().DropLabel(label, moreLabels);            
+        }
+
+        /// <summary>
+        ///     Spawns a <see cref="GraphTraversal{SType, EType}" /> and adds the dropLabel step to that traversal.
+        /// </summary>
+        public static GraphTraversal<object, object> DropLabel(ITraversal labelTraversal)
+        {
+            return new GraphTraversal<object, object>().DropLabel(labelTraversal);            
+        }
         
         /// <summary>
         ///     Spawns a <see cref="GraphTraversal{SType, EType}" /> and adds the length step to that traversal.
diff --git a/gremlin-dotnet/src/Gremlin.Net/Structure/Edge.cs b/gremlin-dotnet/src/Gremlin.Net/Structure/Edge.cs
index 63461fa4b2..d0e2cc01db 100644
--- a/gremlin-dotnet/src/Gremlin.Net/Structure/Edge.cs
+++ b/gremlin-dotnet/src/Gremlin.Net/Structure/Edge.cs
@@ -21,6 +21,8 @@
 
 #endregion
 
+using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Linq;
 
 namespace Gremlin.Net.Structure
@@ -38,13 +40,23 @@ namespace Gremlin.Net.Structure
         /// <param name="label">The label of the edge.</param>
         /// <param name="inV">The incoming/head vertex of the edge.</param>
         /// <param name="properties">Optional properties of the edge.</param>
-        public Edge(object? id, Vertex outV, string label, Vertex inV, dynamic[]? properties = null)
+        /// <param name="labels">Optional set of labels for multi-label support.</param>
+        public Edge(object? id, Vertex outV, string label, Vertex inV, dynamic[]? properties = null,
+            IEnumerable<string>? labels = null)
             : base(id, label, properties)
         {
             OutV = outV;
             InV = inV;
+            Labels = labels != null
+                ? ImmutableHashSet.CreateRange(labels)
+                : ImmutableHashSet.Create(label ?? "edge");
         }
 
+        /// <summary>
+        ///     Gets all labels on this edge.
+        /// </summary>
+        public IReadOnlySet<string> Labels { get; }
+
         /// <summary>
         ///     Gets the incoming/head vertex of this edge.
         /// </summary>
diff --git a/gremlin-dotnet/src/Gremlin.Net/Structure/IO/GraphBinary4/Types/EdgeSerializer.cs b/gremlin-dotnet/src/Gremlin.Net/Structure/IO/GraphBinary4/Types/EdgeSerializer.cs
index b3a8097de5..483d4b3fd8 100644
--- a/gremlin-dotnet/src/Gremlin.Net/Structure/IO/GraphBinary4/Types/EdgeSerializer.cs
+++ b/gremlin-dotnet/src/Gremlin.Net/Structure/IO/GraphBinary4/Types/EdgeSerializer.cs
@@ -47,12 +47,12 @@ namespace Gremlin.Net.Structure.IO.GraphBinary4.Types
             CancellationToken cancellationToken = default)
         {
             await writer.WriteAsync(value.Id, stream, cancellationToken).ConfigureAwait(false);
-            await writer.WriteNonNullableValueAsync(new List<string> { value.Label }, stream, cancellationToken).ConfigureAwait(false);
+            await writer.WriteNonNullableValueAsync(new List<string>(value.Labels), stream, cancellationToken).ConfigureAwait(false);
 
             await writer.WriteAsync(value.InV.Id, stream, cancellationToken).ConfigureAwait(false);
-            await writer.WriteNonNullableValueAsync(new List<string> { value.InV.Label }, stream, cancellationToken).ConfigureAwait(false);
+            await writer.WriteNonNullableValueAsync(new List<string>(value.InV.Labels), stream, cancellationToken).ConfigureAwait(false);
             await writer.WriteAsync(value.OutV.Id, stream, cancellationToken).ConfigureAwait(false);
-            await writer.WriteNonNullableValueAsync(new List<string> { value.OutV.Label }, stream, cancellationToken).ConfigureAwait(false);
+            await writer.WriteNonNullableValueAsync(new List<string>(value.OutV.Labels), stream, cancellationToken).ConfigureAwait(false);
 
             // Placeholder for the parent vertex
             await writer.WriteAsync(null, stream, cancellationToken).ConfigureAwait(false);
@@ -68,14 +68,31 @@ namespace Gremlin.Net.Structure.IO.GraphBinary4.Types
             var id = await reader.ReadAsync(stream, cancellationToken).ConfigureAwait(false);
             var labelList = (List<string?>)await reader.ReadNonNullableValueAsync<List<string?>>(stream, cancellationToken).ConfigureAwait(false);
             var label = labelList.Count > 0 ? labelList[0] ?? "" : "";
+            var labels = new List<string>();
+            foreach (var l in labelList)
+            {
+                if (l != null) labels.Add(l);
+            }
 
             var inVId = await reader.ReadAsync(stream, cancellationToken).ConfigureAwait(false);
             var inVLabelList = (List<string?>)await reader.ReadNonNullableValueAsync<List<string?>>(stream, cancellationToken).ConfigureAwait(false);
-            var inV = new Vertex(inVId, inVLabelList.Count > 0 ? inVLabelList[0] ?? "" : "");
+            var inVLabel = inVLabelList.Count > 0 ? inVLabelList[0] ?? "" : "";
+            var inVLabels = new List<string>();
+            foreach (var l in inVLabelList)
+            {
+                if (l != null) inVLabels.Add(l);
+            }
+            var inV = new Vertex(inVId, inVLabel, labels: inVLabels);
             
             var outVId = await reader.ReadAsync(stream, cancellationToken).ConfigureAwait(false);
             var outVLabelList = (List<string?>)await reader.ReadNonNullableValueAsync<List<string?>>(stream, cancellationToken).ConfigureAwait(false);
-            var outV = new Vertex(outVId, outVLabelList.Count > 0 ? outVLabelList[0] ?? "" : "");
+            var outVLabel = outVLabelList.Count > 0 ? outVLabelList[0] ?? "" : "";
+            var outVLabels = new List<string>();
+            foreach (var l in outVLabelList)
+            {
+                if (l != null) outVLabels.Add(l);
+            }
+            var outV = new Vertex(outVId, outVLabel, labels: outVLabels);
 
             // discard possible parent vertex
             await reader.ReadAsync(stream, cancellationToken).ConfigureAwait(false);
@@ -83,7 +100,7 @@ namespace Gremlin.Net.Structure.IO.GraphBinary4.Types
             var properties = await reader.ReadAsync(stream, cancellationToken).ConfigureAwait(false);
             var propertiesAsArray = null == properties ? Array.Empty<object>() : (properties as List<object>)?.ToArray();
 
-            return new Edge(id, outV, label, inV, propertiesAsArray);
+            return new Edge(id, outV, label, inV, propertiesAsArray, labels);
         }
     }
 }
diff --git a/gremlin-dotnet/src/Gremlin.Net/Structure/IO/GraphBinary4/Types/VertexSerializer.cs b/gremlin-dotnet/src/Gremlin.Net/Structure/IO/GraphBinary4/Types/VertexSerializer.cs
index 9bad7be2d7..2c3e1c2d5e 100644
--- a/gremlin-dotnet/src/Gremlin.Net/Structure/IO/GraphBinary4/Types/VertexSerializer.cs
+++ b/gremlin-dotnet/src/Gremlin.Net/Structure/IO/GraphBinary4/Types/VertexSerializer.cs
@@ -47,7 +47,7 @@ namespace Gremlin.Net.Structure.IO.GraphBinary4.Types
             CancellationToken cancellationToken = default)
         {
             await writer.WriteAsync(value.Id, stream, cancellationToken).ConfigureAwait(false);
-            await writer.WriteNonNullableValueAsync(new List<string> { value.Label }, stream, cancellationToken).ConfigureAwait(false);
+            await writer.WriteNonNullableValueAsync(new List<string>(value.Labels), stream, cancellationToken).ConfigureAwait(false);
             await writer.WriteAsync(null, stream, cancellationToken).ConfigureAwait(false); // properties
         }
 
@@ -58,11 +58,16 @@ namespace Gremlin.Net.Structure.IO.GraphBinary4.Types
             var id = await reader.ReadAsync(stream, cancellationToken).ConfigureAwait(false);
             var labelList = (List<string?>)await reader.ReadNonNullableValueAsync<List<string?>>(stream, cancellationToken).ConfigureAwait(false);
             var label = labelList.Count > 0 ? labelList[0] ?? "" : "";
+            var labels = new List<string>();
+            foreach (var l in labelList)
+            {
+                if (l != null) labels.Add(l);
+            }
 
             var properties = await reader.ReadAsync(stream, cancellationToken).ConfigureAwait(false);
             var propertiesAsArray = null == properties ? Array.Empty<object>() : (properties as List<object>)?.ToArray();
 
-            return new Vertex(id, label, propertiesAsArray);
+            return new Vertex(id, label, propertiesAsArray, labels);
         }
     }
 }
diff --git a/gremlin-dotnet/src/Gremlin.Net/Structure/Vertex.cs b/gremlin-dotnet/src/Gremlin.Net/Structure/Vertex.cs
index 6f56102ac0..036efd46e4 100644
--- a/gremlin-dotnet/src/Gremlin.Net/Structure/Vertex.cs
+++ b/gremlin-dotnet/src/Gremlin.Net/Structure/Vertex.cs
@@ -22,6 +22,7 @@
 #endregion
 
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Linq;
 
 namespace Gremlin.Net.Structure
@@ -42,11 +43,21 @@ namespace Gremlin.Net.Structure
         /// <param name="id">The id of the vertex.</param>
         /// <param name="label">The label of the vertex.</param>
         /// <param name="properties">Optional properties of the vertex.</param>
-        public Vertex(object? id, string label = DefaultLabel, dynamic[]? properties = null)
+        /// <param name="labels">Optional set of labels for multi-label support.</param>
+        public Vertex(object? id, string label = DefaultLabel, dynamic[]? properties = null,
+            IEnumerable<string>? labels = null)
             : base(id, label, properties)
         {
+            Labels = labels != null
+                ? ImmutableHashSet.CreateRange(labels)
+                : ImmutableHashSet.Create(label ?? DefaultLabel);
         }
 
+        /// <summary>
+        ///     Gets all labels on this vertex.
+        /// </summary>
+        public IReadOnlySet<string> Labels { get; }
+
         /// <summary>
         /// Get property by key
         /// </summary>
diff --git a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
index 8ac4ef7b25..6e19a2d5e1 100644
--- a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
+++ b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/Gremlin.cs
@@ -921,6 +921,8 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                {"g_unionXaddEXknowsvarXpropertyXweight_nullXfromXV_hasXname_markoXX_toXV_hasXname_vadasXXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "person").Property("name", "marko").Property("age", 29).AddV((string) "person").Property("name", "vadas").Property("age", 27), (g,p) =>g.Union<object>(__.AddE((string) p["xx1"]).Property("weight", 1).From(__.V().Has("name", "marko")).To(__.V().Has("name", "vadas"))), (g,p) =>g.E( [...]
                {"g_addEXedgeX_fromXV_hasXname_markoXX_toXV_hasXname_vadasXX_propertyXweight_0_5X_withXkey_valueX_valuesXweight_keyX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "person").Property("name", "marko").Property("age", 29).AddV((string) "person").Property("name", "vadas").Property("age", 27), (g,p) =>g.AddE((string) "edge").From(__.V().Has("name", "marko")).To(__.V().Has("name", "vadas")).Property("weight", 0.5).With(" [...]
                {"g_addEXknowsX_fromXV_hasXname_markoXX_toXV_hasXname_vadasXX_propertyXweight_0_5X_addEXknowsX_fromXV_hasXname_markoXX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "person").Property("name", "marko").Property("age", 29).AddV((string) "person").Property("name", "vadas").Property("age", 27), (g,p) =>g.AddE((string) "knows").From(__.V().Has("name", "marko")).To(__.V().Has("name", "vadas")).Property("weight", 0.5).Add [...]
+               {"g_addEXa_bX_from_V_to_V_labels_fold", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "person").Property("name", "marko").AddV((string) "person").Property("name", "josh"), (g,p) =>g.AddE((string) "knows", (string) "trusts").From(__.V().Has("name", "marko")).To(__.V().Has("name", "josh")).Labels().Fold(), (g,p) =>g.E().HasLabel("knows"), (g,p) =>g.E().HasLabel("trusts")}}, 
+               {"g_addEXa_b_cX_from_V_to_V_labels_count", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "person").Property("name", "marko").AddV((string) "person").Property("name", "josh"), (g,p) =>g.AddE((string) "a", (string) "b", (string) "c").From(__.V().Has("name", "marko")).To(__.V().Has("name", "josh")).Labels().Count()}}, 
                {"g_VX1X_addVXanimalX_propertyXage_selectXaX_byXageXX_propertyXname_puppyX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "person").Property("name", "marko").Property("age", 29).As("marko").AddV((string) "person").Property("name", "vadas").Property("age", 27).As("vadas").AddV((string) "software").Property("name", "lop").Property("lang", "java").As("lop").AddV((string) "person").Property("name", "josh").Property("age [...]
                {"g_V_addVXanimalX_propertyXage_0X", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "person").Property("name", "marko").Property("age", 29).As("marko").AddV((string) "person").Property("name", "vadas").Property("age", 27).As("vadas").AddV((string) "software").Property("name", "lop").Property("lang", "java").As("lop").AddV((string) "person").Property("name", "josh").Property("age", 32).As("josh").AddV((string) "softwar [...]
                {"g_V_addVXanimalvarX_propertyXage_0varX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "person").Property("name", "marko").Property("age", 29).As("marko").AddV((string) "person").Property("name", "vadas").Property("age", 27).As("vadas").AddV((string) "software").Property("name", "lop").Property("lang", "java").As("lop").AddV((string) "person").Property("name", "josh").Property("age", 32).As("josh").AddV((string) "s [...]
@@ -956,6 +958,8 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                {"g_V_limitX3X_addVXsoftwareX_aggregateXa1X_byXlabelX_aggregateXa2X_byXlabelX_capXa1_a2X_selectXa_bX_byXunfoldX_foldX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "person").Property("name", "marko").Property("age", 29).As("marko").AddV((string) "person").Property("name", "vadas").Property("age", 27).As("vadas").AddV((string) "software").Property("name", "lop").Property("lang", "java").As("lop").AddV((string) "pers [...]
                {"g_addV_propertyXname_markoX_withXkey_valueX_valuesXname_keyX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV().Property("name", "marko").With("key", "value").Values<object>("name", "key")}}, 
                {"g_addV_propertyXname_marko_since_2010X_withXkey_valueX_propertiesXnameX_valuesXsince_keyX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV().Property("name", "marko", "since", 2010).With("key", "value").Properties<object>("name").Values<object>("since", "key")}}, 
+               {"g_addVXa_bX_labels", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "a", (string) "b").Labels().Fold(), (g,p) =>g.V().HasLabel("a").HasLabel("b"), (g,p) =>g.AddV((string) "a", (string) "b"), (g,p) =>g.V().Labels()}}, 
+               {"g_addVXa_b_cX_labels_count", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "a", (string) "b", (string) "c").Labels().Count()}}, 
                {"g_injectX1X_asBool", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(1).AsBool()}}, 
                {"g_injectX3_14X_asBool", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(3.14).AsBool()}}, 
                {"g_injectXneg_1X_asBool", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(-1).AsBool()}}, 
@@ -1250,6 +1254,11 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                {"g_injectXListX1_2XX_lTrimXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { 1, 2 }).LTrim<object>(Scope.Local)}}, 
                {"g_V_valuesXnameX_lTrim", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "person").Property("name", " marko ").Property("age", 29).As("marko").AddV((string) "person").Property("name", "  vadas  ").Property("age", 27).As("vadas").AddV((string) "software").Property("name", "  lop").Property("lang", "java").As("lop").AddV((string) "person").Property("name", "josh  ").Property("age", 32).As("josh").AddV((string) "softwar [...]
                {"g_V_valuesXnameX_order_fold_lTrimXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "person").Property("name", " marko ").Property("age", 29).As("marko").AddV((string) "person").Property("name", "  vadas  ").Property("age", 27).As("vadas").AddV((string) "software").Property("name", "  lop").Property("lang", "java").As("lop").AddV((string) "person").Property("name", "josh  ").Property("age", 32).As("josh").AddV [...]
+               {"g_V_hasLabelXpersonX_labels", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().HasLabel("person").Labels()}}, 
+               {"g_addVXa_bX_labels_fold", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "a", (string) "b"), (g,p) =>g.V().Labels().Fold()}}, 
+               {"g_addVXa_bX_labels_count", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "a", (string) "b"), (g,p) =>g.V().Labels().Count()}}, 
+               {"g_addV_labels", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV(), (g,p) =>g.V().Labels()}}, 
+               {"g_E_labels", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.E().HasLabel("knows").Labels()}}, 
                {"g_injectXfeature_test_nullX_length", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("feature", "test", null).Length()}}, 
                {"g_injectXfeature_test_nullX_lengthXlocalX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>("feature", "test", null).Length<object>(Scope.Local)}}, 
                {"g_injectXListXa_bXX_length", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.Inject<object>(new List<object> { "a", "b" }).Length()}}, 
@@ -1491,6 +1500,14 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                {"g_mergeV_hidden_label_key_onMatch_matched_prohibited", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.MergeV((IDictionary<object, object>) new Dictionary<object, object> {}).Option(Merge.OnMatch, (IDictionary<object, object>) p["xx1"])}}, 
                {"g_injectXlist1_list2_list3X_fold_asXmX_mergeVXselectXmX_limitXlocal_1X_unfoldX_optionXonCreate_selectXmX_rangeXlocal_1_2X_unfoldX_optionXonMatch_selectXmX_tailXlocalX_unfoldX_to_match", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "person").Property("name", "marko").Property("age", 29), (g,p) =>g.Inject<object>(new Dictionary<object, object> {{ T.Label, "person" }, { "name", "marko" }}, new Dictionary<object, obje [...]
                {"g_injectXlist1_list2_list3X_fold_asXmX_mergeVXselectXmX_limitXlocal_1X_unfoldX_optionXonCreate_selectXmX_rangeXlocal_1_2X_unfoldX_optionXonMatch_selectXmX_tailXlocalX_unfoldX_to_create", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "person").Property("name", "marko").Property("age", 29), (g,p) =>g.Inject<object>(new Dictionary<object, object> {{ T.Label, "person" }, { "name", "stephen" }}, new Dictionary<object, o [...]
+               {"g_mergeVXlabel_ab_name_markoX_multilabel_create", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.MergeV((IDictionary<object, object>) new Dictionary<object, object> {{ T.Label, new List<object> { "person", "employee" } }, { "name", "marko" }}), (g,p) =>g.V(), (g,p) =>g.V().HasLabel("person").HasLabel("employee"), (g,p) =>g.V().Has("name", "marko")}}, 
+               {"g_mergeVXlabel_abc_name_testX_multilabel_create", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.MergeV((IDictionary<object, object>) new Dictionary<object, object> {{ T.Label, new List<object> { "a", "b", "c" } }, { "name", "test" }}), (g,p) =>g.V(), (g,p) =>g.V().HasLabel("a").HasLabel("b").HasLabel("c")}}, 
+               {"g_mergeVXlabel_person_name_markoX_single_label", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.MergeV((IDictionary<object, object>) new Dictionary<object, object> {{ T.Label, "person" }, { "name", "marko" }}), (g,p) =>g.V(), (g,p) =>g.V().HasLabel("person"), (g,p) =>g.V().Has("name", "marko")}}, 
+               {"g_mergeVXlabel_ab_name_markoX_multilabel_match", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "person").AddLabel("employee").Property("name", "marko"), (g,p) =>g.MergeV((IDictionary<object, object>) new Dictionary<object, object> {{ T.Label, new List<object> { "person", "employee" } }, { "name", "marko" }}), (g,p) =>g.V(), (g,p) =>g.V().HasLabel("person").HasLabel("employee")}}, 
+               {"g_mergeVXlabel_ab_name_markoX_multilabel_nomatch", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "person").Property("name", "marko"), (g,p) =>g.MergeV((IDictionary<object, object>) new Dictionary<object, object> {{ T.Label, new List<object> { "person", "employee" } }, { "name", "marko" }}), (g,p) =>g.V()}}, 
+               {"g_mergeVXlabel_person_name_markoX_optionXonMatch_label_managerX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "person").AddLabel("employee").Property("name", "marko"), (g,p) =>g.MergeV((IDictionary<object, object>) new Dictionary<object, object> {{ T.Label, "person" }, { "name", "marko" }}).Option(Merge.OnMatch, (IDictionary<object, object>) new Dictionary<object, object> {{ T.Label, "manager" }}), (g,p) =>g.V(), [...]
+               {"g_mergeVXlabel_person_name_markoX_optionXonMatch_label_manager_directorX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "person").Property("name", "marko"), (g,p) =>g.MergeV((IDictionary<object, object>) new Dictionary<object, object> {{ T.Label, "person" }, { "name", "marko" }}).Option(Merge.OnMatch, (IDictionary<object, object>) new Dictionary<object, object> {{ T.Label, new List<object> { "manager", "director"  [...]
+               {"g_mergeVXlabel_person_name_markoX_optionXonMatch_label_emptyX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "person").Property("name", "marko"), (g,p) =>g.MergeV((IDictionary<object, object>) new Dictionary<object, object> {{ T.Label, "person" }, { "name", "marko" }}).Option(Merge.OnMatch, (IDictionary<object, object>) new Dictionary<object, object> {{ T.Label, new List<object> {  } }}), (g,p) =>g.V(), (g,p) =>g. [...]
                {"g_V_age_min", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("age").Min<object>()}}, 
                {"g_V_foo_min", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("foo").Min<object>()}}, 
                {"g_V_name_min", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Min<object>()}}, 
@@ -1976,6 +1993,10 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                {"g_V_out_out_properties_asXheadX_path_order_byXdescX_selectXheadX_value", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Out().Properties<object>().As("head").Path().Order().By(Order.Desc).Select<object>("head").Value<object>()}}, 
                {"g_V_out_out_values_asXheadX_path_order_byXascX_selectXheadX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Out().Values<object>().As("head").Path().Order().By(Order.Asc).Select<object>("head")}}, 
                {"g_V_out_out_values_asXheadX_path_order_byXdescX_selectXheadX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Out().Values<object>().As("head").Path().Order().By(Order.Desc).Select<object>("head")}}, 
+               {"g_V_hasLabelXpersonX_hasXname_markoX_addLabelXemployeeX_labels", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "person").Property("name", "marko"), (g,p) =>g.V().HasLabel("person").Has("name", "marko").AddLabel("employee").Labels().Fold(), (g,p) =>g.V().HasLabel("person").HasLabel("employee")}}, 
+               {"g_V_addLabelXa_bX_labels_count", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "person"), (g,p) =>g.V().AddLabel("a", "b").Labels().Count()}}, 
+               {"g_V_addLabelXexistingX_labels_count", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "person"), (g,p) =>g.V().AddLabel("person").Labels().Count()}}, 
+               {"g_E_addLabelXfriendX_labels_fold", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "person").Property("name", "marko").As("a").AddV((string) "person").Property("name", "josh").As("b").AddE((string) "knows").From("a").To("b"), (g,p) =>g.E().AddLabel("friend").Labels().Fold(), (g,p) =>g.E().HasLabel("knows"), (g,p) =>g.E().HasLabel("friend")}}, 
                {"g_V_valueXnameX_aggregateXxX_capXxX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Values<object>("name").Aggregate("x").Cap<object>("x")}}, 
                {"g_V_aggregateXxX_byXnameX_capXxX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Aggregate("x").By("name").Cap<object>("x")}}, 
                {"g_V_out_aggregateXaX_path", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Out().Aggregate("a").Path()}}, 
@@ -2033,6 +2054,12 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                {"g_V_repeatXaggregateXaXX_timesX2X_capXaX_unfold", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Repeat(__.Aggregate("a")).Times(2).Cap<object>("a").Unfold<object>()}}, 
                {"g_V_aggregateXaX_capXaX_unfold_both", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Aggregate("a").Cap<object>("a").Unfold<object>().Both()}}, 
                {"g_V_aggregateXaX_capXaX_unfold_barrier_both", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Aggregate("a").Cap<object>("a").Unfold<object>().Barrier().Both()}}, 
+               {"g_V_dropLabelXaX_labels", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "a", (string) "b"), (g,p) =>g.V().DropLabel("a").Labels().Fold(), (g,p) =>g.V().HasLabel("a"), (g,p) =>g.V().HasLabel("b")}}, 
+               {"g_V_dropLabels_labels", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "a", (string) "b"), (g,p) =>g.V().DropLabels().Labels()}}, 
+               {"g_V_dropLabelXa_bX_labels", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "a", (string) "b", (string) "c"), (g,p) =>g.V().DropLabel("a", "b").Labels()}}, 
+               {"g_V_dropLabels_defaultLabel", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "person"), (g,p) =>g.V().DropLabels().Labels()}}, 
+               {"g_E_dropLabelXknowsX_labels", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "person").As("a").AddV((string) "person").As("b").AddE("knows", "trusts").From("a").To("b"), (g,p) =>g.E().DropLabel("knows").Labels().Fold(), (g,p) =>g.E().HasLabel("knows"), (g,p) =>g.E().HasLabel("trusts")}}, 
+               {"g_E_dropLabels_labels", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.AddV((string) "person").As("a").AddV((string) "person").As("b").AddE("knows", "trusts").From("a").To("b"), (g,p) =>g.E().DropLabels().Labels()}}, 
                {"g_V_fail", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Fail()}}, 
                {"g_V_failXmsgX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Fail("msg")}}, 
                {"g_V_unionXout_failX", new List<Func<GraphTraversalSource, IDictionary<string, object>, ITraversal>> {(g,p) =>g.V().Union<object>(__.Out(), __.Fail())}}, 
diff --git a/gremlin-go/driver/anonymousTraversal.go b/gremlin-go/driver/anonymousTraversal.go
index 8a16eb91b8..8eb7c90db6 100644
--- a/gremlin-go/driver/anonymousTraversal.go
+++ b/gremlin-go/driver/anonymousTraversal.go
@@ -63,6 +63,8 @@ type AnonymousTraversal interface {
 	V(args ...interface{}) *GraphTraversal
 	// AddE adds the addE step to the GraphTraversal.
 	AddE(args ...interface{}) *GraphTraversal
+	// AddLabel adds the addLabel step to the GraphTraversal.
+	AddLabel(args ...interface{}) *GraphTraversal
 	// AddV adds the addV step to the GraphTraversal.
 	AddV(args ...interface{}) *GraphTraversal
 	// Aggregate adds the aggregate step to the GraphTraversal.
@@ -133,6 +135,10 @@ type AnonymousTraversal interface {
 	Disjunct(args ...interface{}) *GraphTraversal
 	// Drop adds the drop step to the GraphTraversal.
 	Drop(args ...interface{}) *GraphTraversal
+	// DropLabel adds the dropLabel step to the GraphTraversal.
+	DropLabel(args ...interface{}) *GraphTraversal
+	// DropLabels adds the dropLabels step to the GraphTraversal.
+	DropLabels(args ...interface{}) *GraphTraversal
 	// Element adds the element step to the GraphTraversal.
 	Element(args ...interface{}) *GraphTraversal
 	// ElementMap adds the elementMap step to the GraphTraversal.
@@ -189,6 +195,8 @@ type AnonymousTraversal interface {
 	Key(args ...interface{}) *GraphTraversal
 	// Label adds the label step to the GraphTraversal.
 	Label(args ...interface{}) *GraphTraversal
+	// Labels adds the labels step to the GraphTraversal.
+	Labels(args ...interface{}) *GraphTraversal
 	// Length adds the length step to the GraphTraversal.
 	Length(args ...interface{}) *GraphTraversal
 	// Limit adds the limit step to the GraphTraversal.
@@ -361,6 +369,11 @@ func (anonymousTraversal *anonymousTraversal) AddE(args ...interface{}) *GraphTr
 	return anonymousTraversal.graphTraversal().AddE(args...)
 }
 
+// AddLabel adds the addLabel step to the GraphTraversal.
+func (anonymousTraversal *anonymousTraversal) AddLabel(args ...interface{}) *GraphTraversal {
+	return anonymousTraversal.graphTraversal().AddLabel(args...)
+}
+
 // AddV adds the addV step to the GraphTraversal.
 func (anonymousTraversal *anonymousTraversal) AddV(args ...interface{}) *GraphTraversal {
 	return anonymousTraversal.graphTraversal().AddV(args...)
@@ -536,6 +549,16 @@ func (anonymousTraversal *anonymousTraversal) Drop(args ...interface{}) *GraphTr
 	return anonymousTraversal.graphTraversal().Drop(args...)
 }
 
+// DropLabel adds the dropLabel step to the GraphTraversal.
+func (anonymousTraversal *anonymousTraversal) DropLabel(args ...interface{}) *GraphTraversal {
+	return anonymousTraversal.graphTraversal().DropLabel(args...)
+}
+
+// DropLabels adds the dropLabels step to the GraphTraversal.
+func (anonymousTraversal *anonymousTraversal) DropLabels(args ...interface{}) *GraphTraversal {
+	return anonymousTraversal.graphTraversal().DropLabels(args...)
+}
+
 // Element adds the element step to the GraphTraversal.
 func (anonymousTraversal *anonymousTraversal) Element(args ...interface{}) *GraphTraversal {
 	return anonymousTraversal.graphTraversal().Element(args...)
@@ -676,6 +699,11 @@ func (anonymousTraversal *anonymousTraversal) Label(args ...interface{}) *GraphT
 	return anonymousTraversal.graphTraversal().Label(args...)
 }
 
+// Labels adds the labels step to the GraphTraversal.
+func (anonymousTraversal *anonymousTraversal) Labels(args ...interface{}) *GraphTraversal {
+	return anonymousTraversal.graphTraversal().Labels(args...)
+}
+
 // Length adds the length step to the GraphTraversal.
 func (anonymousTraversal *anonymousTraversal) Length(args ...interface{}) *GraphTraversal {
 	return anonymousTraversal.graphTraversal().Length(args...)
diff --git a/gremlin-go/driver/cucumber/cucumberSteps_test.go b/gremlin-go/driver/cucumber/cucumberSteps_test.go
index b4e44f6415..21b7d95fd5 100644
--- a/gremlin-go/driver/cucumber/cucumberSteps_test.go
+++ b/gremlin-go/driver/cucumber/cucumberSteps_test.go
@@ -1132,7 +1132,6 @@ func TestCucumberFeatures(t *testing.T) {
 		TestSuiteInitializer: InitializeTestSuite,
 		ScenarioInitializer:  InitializeScenario,
 		Options: &godog.Options{
-			Tags:     "~@GraphComputerOnly && ~@AllowNullPropertyValues && ~@StepTree && ~@StepWrite && ~@DataChar",
 			Tags:     "~@GraphComputerOnly && ~@AllowNullPropertyValues && ~@StepTree && ~@StepWrite && ~@DataChar && ~@MultiLabel",
 			Format:   "pretty",
 			Paths:    []string{getEnvOrDefaultString("CUCUMBER_FEATURE_FOLDER", "../../../gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features")},
diff --git a/gremlin-go/driver/cucumber/gremlin.go b/gremlin-go/driver/cucumber/gremlin.go
index 574fdb45fc..e44a411b01 100644
--- a/gremlin-go/driver/cucumber/gremlin.go
+++ b/gremlin-go/driver/cucumber/gremlin.go
@@ -891,6 +891,8 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
     "g_unionXaddEXknowsvarXpropertyXweight_nullXfromXV_hasXname_markoXX_toXV_hasXname_vadasXXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).AddV("person").Property("name", "vadas").Property("age", 27)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Union(gremlingo.T__.AddE(p["xx1"]).Property("weight", 1).From(grem [...]
     "g_addEXedgeX_fromXV_hasXname_markoXX_toXV_hasXname_vadasXX_propertyXweight_0_5X_withXkey_valueX_valuesXweight_keyX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).AddV("person").Property("name", "vadas").Property("age", 27)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddE("edge").From(gremlingo.T__.V().Has(" [...]
     "g_addEXknowsX_fromXV_hasXname_markoXX_toXV_hasXname_vadasXX_propertyXweight_0_5X_addEXknowsX_fromXV_hasXname_markoXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).AddV("person").Property("name", "vadas").Property("age", 27)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddE("knows").From(gremlingo.T__.V().Ha [...]
+    "g_addEXa_bX_from_V_to_V_labels_fold": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").AddV("person").Property("name", "josh")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddE("knows", "trusts").From(gremlingo.T__.V().Has("name", "marko")).To(gremlingo.T__.V().Has("name", "josh")).Labels().Fold()}, func(g *gremlingo.GraphTraversal [...]
+    "g_addEXa_b_cX_from_V_to_V_labels_count": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").AddV("person").Property("name", "josh")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddE("a", "b", "c").From(gremlingo.T__.V().Has("name", "marko")).To(gremlingo.T__.V().Has("name", "josh")).Labels().Count()}}, 
     "g_VX1X_addVXanimalX_propertyXage_selectXaX_byXageXX_propertyXname_puppyX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh").Property("age", 32).As("josh").AddV("software") [...]
     "g_V_addVXanimalX_propertyXage_0X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh").Property("age", 32).As("josh").AddV("software").Property("name", "ripple").Property("la [...]
     "g_V_addVXanimalvarX_propertyXage_0varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh").Property("age", 32).As("josh").AddV("software").Property("name", "ripple").Proper [...]
@@ -926,6 +928,8 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
     "g_V_limitX3X_addVXsoftwareX_aggregateXa1X_byXlabelX_aggregateXa2X_byXlabelX_capXa1_a2X_selectXa_bX_byXunfoldX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh").Prop [...]
     "g_addV_propertyXname_markoX_withXkey_valueX_valuesXname_keyX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV().Property("name", "marko").With("key", "value").Values("name", "key")}}, 
     "g_addV_propertyXname_marko_since_2010X_withXkey_valueX_propertiesXnameX_valuesXsince_keyX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV().Property("name", "marko", "since", 2010).With("key", "value").Properties("name").Values("since", "key")}}, 
+    "g_addVXa_bX_labels": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("a", "b").Labels().Fold()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("a").HasLabel("b")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("a", "b")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremling [...]
+    "g_addVXa_b_cX_labels_count": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("a", "b", "c").Labels().Count()}}, 
     "g_injectX1X_asBool": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(1).AsBool()}}, 
     "g_injectX3_14X_asBool": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(3.14).AsBool()}}, 
     "g_injectXneg_1X_asBool": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(-1).AsBool()}}, 
@@ -1220,6 +1224,11 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
     "g_injectXListX1_2XX_lTrimXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{1, 2}).LTrim(gremlingo.Scope.Local)}}, 
     "g_V_valuesXnameX_lTrim": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", " marko ").Property("age", 29).As("marko").AddV("person").Property("name", "  vadas  ").Property("age", 27).As("vadas").AddV("software").Property("name", "  lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh  ").Property("age", 32).As("josh").AddV("software").Property("name", "   ripple   ").Proper [...]
     "g_V_valuesXnameX_order_fold_lTrimXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", " marko ").Property("age", 29).As("marko").AddV("person").Property("name", "  vadas  ").Property("age", 27).As("vadas").AddV("software").Property("name", "  lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh  ").Property("age", 32).As("josh").AddV("software").Property("name", "    [...]
+    "g_V_hasLabelXpersonX_labels": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("person").Labels()}}, 
+    "g_addVXa_bX_labels_fold": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("a", "b")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Labels().Fold()}}, 
+    "g_addVXa_bX_labels_count": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("a", "b")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Labels().Count()}}, 
+    "g_addV_labels": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Labels()}}, 
+    "g_E_labels": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E().HasLabel("knows").Labels()}}, 
     "g_injectXfeature_test_nullX_length": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("feature", "test", nil).Length()}}, 
     "g_injectXfeature_test_nullX_lengthXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject("feature", "test", nil).Length(gremlingo.Scope.Local)}}, 
     "g_injectXListXa_bXX_length": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{"a", "b"}).Length()}}, 
@@ -1461,6 +1470,14 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
     "g_mergeV_hidden_label_key_onMatch_matched_prohibited": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(map[interface{}]interface{}{ }).Option(gremlingo.Merge.OnMatch, p["xx1"])}}, 
     "g_injectXlist1_list2_list3X_fold_asXmX_mergeVXselectXmX_limitXlocal_1X_unfoldX_optionXonCreate_selectXmX_rangeXlocal_1_2X_unfoldX_optionXonMatch_selectXmX_tailXlocalX_unfoldX_to_match": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(map[interface{}]interface{ [...]
     "g_injectXlist1_list2_list3X_fold_asXmX_mergeVXselectXmX_limitXlocal_1X_unfoldX_optionXonCreate_selectXmX_rangeXlocal_1_2X_unfoldX_optionXonMatch_selectXmX_tailXlocalX_unfoldX_to_create": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(map[interface{}]interface [...]
+    "g_mergeVXlabel_ab_name_markoX_multilabel_create": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(map[interface{}]interface{}{gremlingo.T.Label: []interface{}{"person", "employee"}, "name": "marko" })}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel [...]
+    "g_mergeVXlabel_abc_name_testX_multilabel_create": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(map[interface{}]interface{}{gremlingo.T.Label: []interface{}{"a", "b", "c"}, "name": "test" })}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("a").Ha [...]
+    "g_mergeVXlabel_person_name_markoX_single_label": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(map[interface{}]interface{}{gremlingo.T.Label: "person", "name": "marko" })}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("person")}, func(g *gremlin [...]
+    "g_mergeVXlabel_ab_name_markoX_multilabel_match": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").AddLabel("employee").Property("name", "marko")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(map[interface{}]interface{}{gremlingo.T.Label: []interface{}{"person", "employee"}, "name": "marko" })}, func(g *gremlingo.GraphTraversalSource, p map[string]inte [...]
+    "g_mergeVXlabel_ab_name_markoX_multilabel_nomatch": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(map[interface{}]interface{}{gremlingo.T.Label: []interface{}{"person", "employee"}, "name": "marko" })}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo [...]
+    "g_mergeVXlabel_person_name_markoX_optionXonMatch_label_managerX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").AddLabel("employee").Property("name", "marko")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(map[interface{}]interface{}{gremlingo.T.Label: "person", "name": "marko" }).Option(gremlingo.Merge.OnMatch, map[interface{}]interface{}{gremlingo [...]
+    "g_mergeVXlabel_person_name_markoX_optionXonMatch_label_manager_directorX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(map[interface{}]interface{}{gremlingo.T.Label: "person", "name": "marko" }).Option(gremlingo.Merge.OnMatch, map[interface{}]interface{}{gremlingo.T.Label: [] [...]
+    "g_mergeVXlabel_person_name_markoX_optionXonMatch_label_emptyX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(map[interface{}]interface{}{gremlingo.T.Label: "person", "name": "marko" }).Option(gremlingo.Merge.OnMatch, map[interface{}]interface{}{gremlingo.T.Label: []interface{} [...]
     "g_V_age_min": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").Min()}}, 
     "g_V_foo_min": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("foo").Min()}}, 
     "g_V_name_min": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Min()}}, 
@@ -1946,6 +1963,10 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
     "g_V_out_out_properties_asXheadX_path_order_byXdescX_selectXheadX_value": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Out().Properties().As("head").Path().Order().By(gremlingo.Order.Desc).Select("head").Value()}}, 
     "g_V_out_out_values_asXheadX_path_order_byXascX_selectXheadX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Out().Values().As("head").Path().Order().By(gremlingo.Order.Asc).Select("head")}}, 
     "g_V_out_out_values_asXheadX_path_order_byXdescX_selectXheadX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Out().Values().As("head").Path().Order().By(gremlingo.Order.Desc).Select("head")}}, 
+    "g_V_hasLabelXpersonX_hasXname_markoX_addLabelXemployeeX_labels": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("person").Has("name", "marko").AddLabel("employee").Labels().Fold()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal [...]
+    "g_V_addLabelXa_bX_labels_count": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().AddLabel("a", "b").Labels().Count()}}, 
+    "g_V_addLabelXexistingX_labels_count": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().AddLabel("person").Labels().Count()}}, 
+    "g_E_addLabelXfriendX_labels_fold": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "josh").As("b").AddE("knows").From("a").To("b")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E().AddLabel("friend").Labels().Fold()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremling [...]
     "g_V_valueXnameX_aggregateXxX_capXxX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Aggregate("x").Cap("x")}}, 
     "g_V_aggregateXxX_byXnameX_capXxX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Aggregate("x").By("name").Cap("x")}}, 
     "g_V_out_aggregateXaX_path": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Aggregate("a").Path()}}, 
@@ -2003,6 +2024,12 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
     "g_V_repeatXaggregateXaXX_timesX2X_capXaX_unfold": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Repeat(gremlingo.T__.Aggregate("a")).Times(2).Cap("a").Unfold()}}, 
     "g_V_aggregateXaX_capXaX_unfold_both": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Aggregate("a").Cap("a").Unfold().Both()}}, 
     "g_V_aggregateXaX_capXaX_unfold_barrier_both": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Aggregate("a").Cap("a").Unfold().Barrier().Both()}}, 
+    "g_V_dropLabelXaX_labels": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("a", "b")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().DropLabel("a").Labels().Fold()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("a")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.Gra [...]
+    "g_V_dropLabels_labels": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("a", "b")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().DropLabels().Labels()}}, 
+    "g_V_dropLabelXa_bX_labels": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("a", "b", "c")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().DropLabel("a", "b").Labels()}}, 
+    "g_V_dropLabels_defaultLabel": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().DropLabels().Labels()}}, 
+    "g_E_dropLabelXknowsX_labels": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").As("a").AddV("person").As("b").AddE("knows", "trusts").From("a").To("b")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E().DropLabel("knows").Labels().Fold()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E().HasLabel("knows [...]
+    "g_E_dropLabels_labels": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").As("a").AddV("person").As("b").AddE("knows", "trusts").From("a").To("b")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E().DropLabels().Labels()}}, 
     "g_V_fail": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Fail()}}, 
     "g_V_failXmsgX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Fail("msg")}}, 
     "g_V_unionXout_failX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Union(gremlingo.T__.Out(), gremlingo.T__.Fail())}}, 
diff --git a/gremlin-go/driver/graph.go b/gremlin-go/driver/graph.go
index 981a7fc2d3..1431b3f41b 100644
--- a/gremlin-go/driver/graph.go
+++ b/gremlin-go/driver/graph.go
@@ -57,13 +57,15 @@ type Element struct {
 // Vertex contains a single Vertex which has a Label and an Id.
 type Vertex struct {
 	Element
+	Labels []string // All labels; Element.Label still holds first label for compat
 }
 
 // Edge links two Vertex structs along with its Property Objects. An edge has both a direction and a Label.
 type Edge struct {
 	Element
-	OutV Vertex
-	InV  Vertex
+	OutV   Vertex
+	InV    Vertex
+	Labels []string // All labels
 }
 
 // VertexProperty is similar to property in that it denotes a key/value pair associated with a Vertex, but is different
diff --git a/gremlin-go/driver/graphBinaryDeserializer.go b/gremlin-go/driver/graphBinaryDeserializer.go
index f13acf9eac..cfc17c4dd9 100644
--- a/gremlin-go/driver/graphBinaryDeserializer.go
+++ b/gremlin-go/driver/graphBinaryDeserializer.go
@@ -360,7 +360,13 @@ func (d *GraphBinaryDeserializer) readVertex(withProps bool) (*Vertex, error) {
 	if !ok {
 		return nil, newError(err0404ReadNullTypeError)
 	}
-	v := &Vertex{Element: Element{Id: id, Label: label}}
+	allLabels := make([]string, 0, len(labelSlice))
+	for _, l := range labelSlice {
+		if s, ok := l.(string); ok {
+			allLabels = append(allLabels, s)
+		}
+	}
+	v := &Vertex{Element: Element{Id: id, Label: label}, Labels: allLabels}
 	if withProps {
 		props, err := d.ReadFullyQualified()
 		if err != nil {
@@ -391,6 +397,12 @@ func (d *GraphBinaryDeserializer) readEdge() (*Edge, error) {
 	if !ok {
 		return nil, newError(err0404ReadNullTypeError)
 	}
+	allLabels := make([]string, 0, len(labelSlice))
+	for _, l := range labelSlice {
+		if s, ok := l.(string); ok {
+			allLabels = append(allLabels, s)
+		}
+	}
 	inV, err := d.readVertex(false)
 	if err != nil {
 		return nil, err
@@ -410,6 +422,7 @@ func (d *GraphBinaryDeserializer) readEdge() (*Edge, error) {
 		Element: Element{Id: id, Label: label},
 		InV:     *inV,
 		OutV:    *outV,
+		Labels:  allLabels,
 	}
 	e.Properties = make([]interface{}, 0)
 	if props != nil {
diff --git a/gremlin-go/driver/graphBinarySerializer.go b/gremlin-go/driver/graphBinarySerializer.go
index f169b7fde6..4e891296a4 100644
--- a/gremlin-go/driver/graphBinarySerializer.go
+++ b/gremlin-go/driver/graphBinarySerializer.go
@@ -268,8 +268,12 @@ func vertexWriter(value interface{}, w io.Writer, typeSerializer *graphBinaryTyp
 		return err
 	}
 
-	// Not fully qualified.
-	if err := typeSerializer.writeValue([1]string{v.Label}, w, false); err != nil {
+	// Write all labels as a list. Use Labels slice if populated, otherwise fall back to single Label.
+	labels := v.Labels
+	if len(labels) == 0 {
+		labels = []string{v.Label}
+	}
+	if err := typeSerializer.writeValue(labels, w, false); err != nil {
 		return err
 	}
 	// Note that as TinkerPop currently send "references" only, properties will always be null
@@ -284,8 +288,12 @@ func edgeWriter(value interface{}, w io.Writer, typeSerializer *graphBinaryTypeS
 		return err
 	}
 
-	// Not fully qualified
-	if err := typeSerializer.writeValue([1]string{e.Label}, w, false); err != nil {
+	// Write all labels as a list. Use Labels slice if populated, otherwise fall back to single Label.
+	labels := e.Labels
+	if len(labels) == 0 {
+		labels = []string{e.Label}
+	}
+	if err := typeSerializer.writeValue(labels, w, false); err != nil {
 		return err
 	}
 
@@ -294,8 +302,12 @@ func edgeWriter(value interface{}, w io.Writer, typeSerializer *graphBinaryTypeS
 		return err
 	}
 
-	// Not fully qualified.
-	if err := typeSerializer.writeValue([1]string{e.InV.Label}, w, false); err != nil {
+	// Write in-vertex labels
+	inVLabels := e.InV.Labels
+	if len(inVLabels) == 0 {
+		inVLabels = []string{e.InV.Label}
+	}
+	if err := typeSerializer.writeValue(inVLabels, w, false); err != nil {
 		return err
 	}
 	// Write out-vertex
@@ -303,8 +315,12 @@ func edgeWriter(value interface{}, w io.Writer, typeSerializer *graphBinaryTypeS
 		return err
 	}
 
-	// Not fully qualified.
-	if err := typeSerializer.writeValue([1]string{e.OutV.Label}, w, false); err != nil {
+	// Write out-vertex labels
+	outVLabels := e.OutV.Labels
+	if len(outVLabels) == 0 {
+		outVLabels = []string{e.OutV.Label}
+	}
+	if err := typeSerializer.writeValue(outVLabels, w, false); err != nil {
 		return err
 	}
 
diff --git a/gremlin-go/driver/graphTraversal.go b/gremlin-go/driver/graphTraversal.go
index 03aa682706..a18d7aee95 100644
--- a/gremlin-go/driver/graphTraversal.go
+++ b/gremlin-go/driver/graphTraversal.go
@@ -78,6 +78,12 @@ func (g *GraphTraversal) AddE(args ...interface{}) *GraphTraversal {
 	return g
 }
 
+// AddLabel adds the addLabel step to the GraphTraversal.
+func (g *GraphTraversal) AddLabel(args ...interface{}) *GraphTraversal {
+	g.GremlinLang.AddStep("addLabel", args...)
+	return g
+}
+
 // AddV adds the addV step to the GraphTraversal.
 func (g *GraphTraversal) AddV(args ...interface{}) *GraphTraversal {
 	g.GremlinLang.AddStep("addV", args...)
@@ -290,6 +296,18 @@ func (g *GraphTraversal) Drop(args ...interface{}) *GraphTraversal {
 	return g
 }
 
+// DropLabel adds the dropLabel step to the GraphTraversal.
+func (g *GraphTraversal) DropLabel(args ...interface{}) *GraphTraversal {
+	g.GremlinLang.AddStep("dropLabel", args...)
+	return g
+}
+
+// DropLabels adds the dropLabels step to the GraphTraversal.
+func (g *GraphTraversal) DropLabels(args ...interface{}) *GraphTraversal {
+	g.GremlinLang.AddStep("dropLabels", args...)
+	return g
+}
+
 // Element adds the element step to the GraphTraversal.
 func (g *GraphTraversal) Element(args ...interface{}) *GraphTraversal {
 	g.GremlinLang.AddStep("element", args...)
@@ -465,6 +483,12 @@ func (g *GraphTraversal) Label(args ...interface{}) *GraphTraversal {
 	return g
 }
 
+// Labels adds the labels step to the GraphTraversal.
+func (g *GraphTraversal) Labels(args ...interface{}) *GraphTraversal {
+	g.GremlinLang.AddStep("labels", args...)
+	return g
+}
+
 // Length adds the length step to the GraphTraversal.
 func (g *GraphTraversal) Length(args ...interface{}) *GraphTraversal {
 	g.GremlinLang.AddStep("length", args...)
diff --git a/gremlin-go/driver/graph_test.go b/gremlin-go/driver/graph_test.go
index 0de4a1bac9..5599857d7f 100644
--- a/gremlin-go/driver/graph_test.go
+++ b/gremlin-go/driver/graph_test.go
@@ -30,7 +30,7 @@ import (
 func TestGraphStructureFunctions(t *testing.T) {
 	t.Run("Test Vertex.String()", func(t *testing.T) {
 		uid, _ := uuid.NewUUID()
-		v := Vertex{Element{uid, "Vertex-Label", nil}}
+		v := Vertex{Element: Element{uid, "Vertex-Label", nil}}
 		assert.Equal(t, fmt.Sprintf("v[%s]", uid.String()), v.String())
 	})
 
@@ -38,14 +38,14 @@ func TestGraphStructureFunctions(t *testing.T) {
 		uidEdge, _ := uuid.NewUUID()
 		uidIn, _ := uuid.NewUUID()
 		uidOut, _ := uuid.NewUUID()
-		v := Edge{Element{uidEdge, "edge_label", nil}, Vertex{Element{uidOut, "vertex_out", nil}}, Vertex{Element{uidIn, "vertex_in", nil}}}
+		v := Edge{Element: Element{uidEdge, "edge_label", nil}, OutV: Vertex{Element: Element{uidOut, "vertex_out", nil}}, InV: Vertex{Element: Element{uidIn, "vertex_in", nil}}}
 		assert.Equal(t, fmt.Sprintf("e[%s][%s-edge_label->%s]", uidEdge.String(), uidOut.String(), uidIn.String()), v.String())
 	})
 
 	t.Run("Test VertexProperty.String()", func(t *testing.T) {
 		uidVProp, _ := uuid.NewUUID()
 		uidV, _ := uuid.NewUUID()
-		v := VertexProperty{Element{uidVProp, "Vertex-prop", nil}, "Vertex", []uint32{0, 1}, Vertex{Element{uidV, "Vertex", nil}}}
+		v := VertexProperty{Element{uidVProp, "Vertex-prop", nil}, "Vertex", []uint32{0, 1}, Vertex{Element: Element{uidV, "Vertex", nil}}}
 		assert.Equal(t, "vp[Vertex-prop->[0 1]]", v.String())
 	})
 
diff --git a/gremlin-js/gremlin-javascript/lib/process/graph-traversal.ts b/gremlin-js/gremlin-javascript/lib/process/graph-traversal.ts
index 48362a148b..2bc1448226 100644
--- a/gremlin-js/gremlin-javascript/lib/process/graph-traversal.ts
+++ b/gremlin-js/gremlin-javascript/lib/process/graph-traversal.ts
@@ -403,6 +403,16 @@ export class GraphTraversal extends Traversal {
     return this;
   }
 
+  /**
+   * Graph traversal addLabel method.
+   * @param {...Object} args
+   * @returns {GraphTraversal}
+   */
+  addLabel(...args: any[]): this {
+    this.gremlinLang.addStep('addLabel', args);
+    return this;
+  }
+
   /**
    * Graph traversal aggregate method.
    * @param {...Object} args
@@ -742,6 +752,26 @@ export class GraphTraversal extends Traversal {
     return this;
   }
 
+  /**
+   * Graph traversal dropLabel method.
+   * @param {...Object} args
+   * @returns {GraphTraversal}
+   */
+  dropLabel(...args: any[]): this {
+    this.gremlinLang.addStep('dropLabel', args);
+    return this;
+  }
+
+  /**
+   * Graph traversal dropLabels method.
+   * @param {...Object} args
+   * @returns {GraphTraversal}
+   */
+  dropLabels(...args: any[]): this {
+    this.gremlinLang.addStep('dropLabels', args);
+    return this;
+  }
+
   /**
    * Graph traversal element method.
    * @param {...Object} args
@@ -1026,6 +1056,16 @@ export class GraphTraversal extends Traversal {
     return this;
   }
 
+  /**
+   * Graph traversal labels method.
+   * @param {...Object} args
+   * @returns {GraphTraversal}
+   */
+  labels(...args: any[]): this {
+    this.gremlinLang.addStep('labels', args);
+    return this;
+  }
+
   /**
    * Graph traversal length method.
    * @param {...Object} args
@@ -1784,6 +1824,7 @@ export const statics = {
   V: (...args: any[]) => callOnEmptyTraversal('V', args),
   addE: (...args: any[]) => callOnEmptyTraversal('addE', args),
   addV: (...args: any[]) => callOnEmptyTraversal('addV', args),
+  addLabel: (...args: any[]) => callOnEmptyTraversal('addLabel', args),
   aggregate: (...args: any[]) => callOnEmptyTraversal('aggregate', args),
   all: (...args: any[]) => callOnEmptyTraversal('all', args),
   and: (...args: any[]) => callOnEmptyTraversal('and', args),
@@ -1816,6 +1857,8 @@ export const statics = {
   discard: (...args: any[]) => callOnEmptyTraversal('discard', args),
   disjunct: (...args: any[]) => callOnEmptyTraversal('disjunct', args),
   drop: (...args: any[]) => callOnEmptyTraversal('drop', args),
+  dropLabel: (...args: any[]) => callOnEmptyTraversal('dropLabel', args),
+  dropLabels: (...args: any[]) => callOnEmptyTraversal('dropLabels', args),
   element: (...args: any[]) => callOnEmptyTraversal('element', args),
   elementMap: (...args: any[]) => callOnEmptyTraversal('elementMap', args),
   emit: (...args: any[]) => callOnEmptyTraversal('emit', args),
@@ -1843,6 +1886,7 @@ export const statics = {
   is: (...args: any[]) => callOnEmptyTraversal('is', args),
   key: (...args: any[]) => callOnEmptyTraversal('key', args),
   label: (...args: any[]) => callOnEmptyTraversal('label', args),
+  labels: (...args: any[]) => callOnEmptyTraversal('labels', args),
   length: (...args: any[]) => callOnEmptyTraversal('length', args),
   limit: (...args: any[]) => callOnEmptyTraversal('limit', args),
   local: (...args: any[]) => callOnEmptyTraversal('local', args),
diff --git a/gremlin-js/gremlin-javascript/lib/structure/graph.ts b/gremlin-js/gremlin-javascript/lib/structure/graph.ts
index 8b91828512..c9b64e7324 100644
--- a/gremlin-js/gremlin-javascript/lib/structure/graph.ts
+++ b/gremlin-js/gremlin-javascript/lib/structure/graph.ts
@@ -67,12 +67,23 @@ export class Vertex<
     [P in keyof TProperties]: P extends string ? VertexProperties<P, TProperties[P]> : never;
   },
 > extends Element<TLabel, TId> {
+  readonly labels: Set<string>;
+
   constructor(
     id: TId,
-    label: TLabel,
+    label: TLabel | string[],
     properties: Property[] | null = [],
+    labels?: string[],
   ) {
-    super(id, label, properties ?? []);
+    // Determine the canonical labels array from either explicit labels param or label param
+    const resolvedLabels: string[] = labels
+      ? labels
+      : Array.isArray(label) ? label
+      : label ? [label as string]
+      : ['vertex'];
+    const primaryLabel = (resolvedLabels.length > 0 ? resolvedLabels[0] : 'vertex') as TLabel;
+    super(id, primaryLabel, properties ?? []);
+    this.labels = new Set(resolvedLabels);
   }
 
   toString() {
@@ -87,14 +98,25 @@ export class Edge<
   TProperties extends Record<string, any> = Record<string, any>,
   TId = number,
 > extends Element<TLabel, TId> {
+  readonly labels: Set<string>;
+
   constructor(
     id: TId,
     readonly outV: TOutVertex,
-    readonly label: TLabel,
+    label: TLabel | string[],
     readonly inV: TInVertex,
     properties: Property[] | null = [],
+    labels?: string[],
   ) {
-    super(id, label, properties ?? []);
+    // Determine the canonical labels array from either explicit labels param or label param
+    const resolvedLabels: string[] = labels
+      ? labels
+      : Array.isArray(label) ? label
+      : label ? [label as string]
+      : ['edge'];
+    const primaryLabel = (resolvedLabels.length > 0 ? resolvedLabels[0] : 'edge') as TLabel;
+    super(id, primaryLabel, properties ?? []);
+    this.labels = new Set(resolvedLabels);
   }
 
   toString() {
diff --git a/gremlin-js/gremlin-javascript/lib/structure/io/binary/internals/EdgeSerializer.js b/gremlin-js/gremlin-javascript/lib/structure/io/binary/internals/EdgeSerializer.js
index 5ec2307b01..88d1a2ee53 100644
--- a/gremlin-js/gremlin-javascript/lib/structure/io/binary/internals/EdgeSerializer.js
+++ b/gremlin-js/gremlin-javascript/lib/structure/io/binary/internals/EdgeSerializer.js
@@ -59,7 +59,14 @@ export default class EdgeSerializer {
     bufs.push(this.ioc.anySerializer.serialize(item.id));
 
     // {label}
-    const labels = Array.isArray(item.label) ? item.label : item.label ? [item.label] : [];
+    const labels =
+      item.labels instanceof Set
+        ? Array.from(item.labels)
+        : Array.isArray(item.label)
+          ? item.label
+          : item.label
+            ? [item.label]
+            : [];
     bufs.push(this.ioc.listSerializer.serialize(labels, false));
 
     // {inVId}
@@ -67,8 +74,14 @@ export default class EdgeSerializer {
     bufs.push(this.ioc.anySerializer.serialize(inVId));
 
     // {inVLabel}
-    const inVLabel = item.inV && item.inV.label;
-    const inVLabels = Array.isArray(inVLabel) ? inVLabel : inVLabel ? [inVLabel] : [];
+    const inVLabels =
+      item.inV && item.inV.labels instanceof Set
+        ? Array.from(item.inV.labels)
+        : item.inV && Array.isArray(item.inV.label)
+          ? item.inV.label
+          : item.inV && item.inV.label
+            ? [item.inV.label]
+            : [];
     bufs.push(this.ioc.listSerializer.serialize(inVLabels, false));
 
     // {outVId}
@@ -76,8 +89,14 @@ export default class EdgeSerializer {
     bufs.push(this.ioc.anySerializer.serialize(outVId));
 
     // {outVLabel}
-    const outVLabel = item.outV && item.outV.label;
-    const outVLabels = Array.isArray(outVLabel) ? outVLabel : outVLabel ? [outVLabel] : [];
+    const outVLabels =
+      item.outV && item.outV.labels instanceof Set
+        ? Array.from(item.outV.labels)
+        : item.outV && Array.isArray(item.outV.label)
+          ? item.outV.label
+          : item.outV && item.outV.label
+            ? [item.outV.label]
+            : [];
     bufs.push(this.ioc.listSerializer.serialize(outVLabels, false));
 
     // {parent}
@@ -100,23 +119,26 @@ export default class EdgeSerializer {
     // {id} fully qualified
     const id = await this.ioc.anySerializer.deserialize(reader);
 
-    // {label} bare list, extract first element
+    // {label} bare list - full multi-label list
     const labelList = await this.ioc.listSerializer.deserializeValue(reader, 0x00, this.ioc.DataType.LIST);
-    const label = Array.isArray(labelList) && labelList.length > 0 ? labelList[0] : labelList;
+    const labels = Array.isArray(labelList) ? labelList : labelList ? [labelList] : [];
+    const label = labels.length > 0 ? labels[0] : 'edge';
 
     // {inVId} fully qualified
     const inVId = await this.ioc.anySerializer.deserialize(reader);
 
-    // {inVLabel} bare list, extract first element
+    // {inVLabel} bare list - full multi-label list
     const inVLabelList = await this.ioc.listSerializer.deserializeValue(reader, 0x00, this.ioc.DataType.LIST);
-    const inVLabel = Array.isArray(inVLabelList) && inVLabelList.length > 0 ? inVLabelList[0] : inVLabelList;
+    const inVLabels = Array.isArray(inVLabelList) ? inVLabelList : inVLabelList ? [inVLabelList] : [];
+    const inVLabel = inVLabels.length > 0 ? inVLabels[0] : 'vertex';
 
     // {outVId} fully qualified
     const outVId = await this.ioc.anySerializer.deserialize(reader);
 
-    // {outVLabel} bare list, extract first element
+    // {outVLabel} bare list - full multi-label list
     const outVLabelList = await this.ioc.listSerializer.deserializeValue(reader, 0x00, this.ioc.DataType.LIST);
-    const outVLabel = Array.isArray(outVLabelList) && outVLabelList.length > 0 ? outVLabelList[0] : outVLabelList;
+    const outVLabels = Array.isArray(outVLabelList) ? outVLabelList : outVLabelList ? [outVLabelList] : [];
+    const outVLabel = outVLabels.length > 0 ? outVLabels[0] : 'vertex';
 
     // {parent} fully qualified (always null in current TinkerPop)
     await this.ioc.anySerializer.deserialize(reader);
@@ -126,10 +148,11 @@ export default class EdgeSerializer {
 
     return new Edge(
       id,
-      new Vertex(outVId, outVLabel, null),
+      new Vertex(outVId, outVLabel, null, outVLabels),
       label,
-      new Vertex(inVId, inVLabel, null),
+      new Vertex(inVId, inVLabel, null, inVLabels),
       properties || [],
+      labels,
     );
   }
 
diff --git a/gremlin-js/gremlin-javascript/lib/structure/io/binary/internals/GraphSerializer.js b/gremlin-js/gremlin-javascript/lib/structure/io/binary/internals/GraphSerializer.js
index abf8ac5e2e..5c843b4445 100644
--- a/gremlin-js/gremlin-javascript/lib/structure/io/binary/internals/GraphSerializer.js
+++ b/gremlin-js/gremlin-javascript/lib/structure/io/binary/internals/GraphSerializer.js
@@ -56,8 +56,9 @@ export default class GraphSerializer {
       // {id}
       bufs.push(this.ioc.anySerializer.serialize(v.id));
 
-      // {label} as 1-element list (value-only)
-      bufs.push(this.ioc.listSerializer.serialize([v.label], false));
+      // {label} as list (value-only)
+      const vLabels = v.labels instanceof Set ? Array.from(v.labels) : [v.label];
+      bufs.push(this.ioc.listSerializer.serialize(vLabels, false));
 
       const vps = Array.isArray(v.properties) ? v.properties : [];
 
@@ -91,8 +92,9 @@ export default class GraphSerializer {
       // {id}
       bufs.push(this.ioc.anySerializer.serialize(e.id));
 
-      // {label} as 1-element list (value-only)
-      bufs.push(this.ioc.listSerializer.serialize([e.label], false));
+      // {label} as list (value-only)
+      const eLabels = e.labels instanceof Set ? Array.from(e.labels) : [e.label];
+      bufs.push(this.ioc.listSerializer.serialize(eLabels, false));
 
       // {inV_id}
       bufs.push(this.ioc.anySerializer.serialize(e.inV && e.inV.id));
@@ -133,11 +135,12 @@ export default class GraphSerializer {
       // {id} fully qualified
       const vId = await this.ioc.anySerializer.deserialize(reader);
 
-      // {label} value-only list, first element
+      // {label} value-only list - full multi-label list
       const vLabelList = await this.ioc.listSerializer.deserializeValue(reader, 0x00, this.ioc.DataType.LIST);
-      const vLabel = Array.isArray(vLabelList) && vLabelList.length > 0 ? vLabelList[0] : vLabelList;
+      const vLabels = Array.isArray(vLabelList) ? vLabelList : vLabelList ? [vLabelList] : [];
+      const vLabel = vLabels.length > 0 ? vLabels[0] : 'vertex';
 
-      const vertex = new Vertex(vId, vLabel, []);
+      const vertex = new Vertex(vId, vLabel, [], vLabels);
       graph.vertices.set(vId, vertex);
 
       // {vp_count} bare int
@@ -170,9 +173,10 @@ export default class GraphSerializer {
       // {id} fully qualified
       const eId = await this.ioc.anySerializer.deserialize(reader);
 
-      // {label} value-only list, first element
+      // {label} value-only list - full multi-label list
       const eLabelList = await this.ioc.listSerializer.deserializeValue(reader, 0x00, this.ioc.DataType.LIST);
-      const eLabel = Array.isArray(eLabelList) && eLabelList.length > 0 ? eLabelList[0] : eLabelList;
+      const eLabels = Array.isArray(eLabelList) ? eLabelList : eLabelList ? [eLabelList] : [];
+      const eLabel = eLabels.length > 0 ? eLabels[0] : 'edge';
 
       // {inV_id} fully qualified
       const inVId = await this.ioc.anySerializer.deserialize(reader);
@@ -196,7 +200,7 @@ export default class GraphSerializer {
       const inV = graph.vertices.get(inVId) || new Vertex(inVId, '', []);
       const outV = graph.vertices.get(outVId) || new Vertex(outVId, '', []);
 
-      const edge = new Edge(eId, outV, eLabel, inV, edgeProps || []);
+      const edge = new Edge(eId, outV, eLabel, inV, edgeProps || [], eLabels);
       graph.edges.set(eId, edge);
     }
 
diff --git a/gremlin-js/gremlin-javascript/lib/structure/io/binary/internals/VertexSerializer.js b/gremlin-js/gremlin-javascript/lib/structure/io/binary/internals/VertexSerializer.js
index 49771247d0..4c64e1df8d 100644
--- a/gremlin-js/gremlin-javascript/lib/structure/io/binary/internals/VertexSerializer.js
+++ b/gremlin-js/gremlin-javascript/lib/structure/io/binary/internals/VertexSerializer.js
@@ -54,7 +54,14 @@ export default class VertexSerializer {
     bufs.push(this.ioc.anySerializer.serialize(item.id));
 
     // {label}
-    const labels = Array.isArray(item.label) ? item.label : item.label ? [item.label] : [];
+    const labels =
+      item.labels instanceof Set
+        ? Array.from(item.labels)
+        : Array.isArray(item.label)
+          ? item.label
+          : item.label
+            ? [item.label]
+            : [];
     bufs.push(this.ioc.listSerializer.serialize(labels, false));
 
     // {properties}
@@ -74,14 +81,15 @@ export default class VertexSerializer {
     // {id} fully qualified
     const id = await this.ioc.anySerializer.deserialize(reader);
 
-    // {label} bare list, extract first element
+    // {label} bare list - full multi-label list
     const labelList = await this.ioc.listSerializer.deserializeValue(reader, 0x00, this.ioc.DataType.LIST);
-    const label = Array.isArray(labelList) && labelList.length > 0 ? labelList[0] : labelList;
+    const labels = Array.isArray(labelList) ? labelList : labelList ? [labelList] : [];
+    const label = labels.length > 0 ? labels[0] : 'vertex';
 
     // {properties} fully qualified
     const properties = await this.ioc.anySerializer.deserialize(reader);
 
-    return new Vertex(id, label, properties || []);
+    return new Vertex(id, label, properties || [], labels);
   }
 
   /**
diff --git a/gremlin-js/gremlin-javascript/test/cucumber/gremlin.js b/gremlin-js/gremlin-javascript/test/cucumber/gremlin.js
index aef279b28a..b0ff76c57d 100644
--- a/gremlin-js/gremlin-javascript/test/cucumber/gremlin.js
+++ b/gremlin-js/gremlin-javascript/test/cucumber/gremlin.js
@@ -922,6 +922,8 @@ const gremlins = {
     g_unionXaddEXknowsvarXpropertyXweight_nullXfromXV_hasXname_markoXX_toXV_hasXname_vadasXXX: [function({g, xx1}) { return g.addV("person").property("name", "marko").property("age", 29).addV("person").property("name", "vadas").property("age", 27) }, function({g, xx1}) { return g.union(__.addE(xx1).property("weight", 1).from_(__.V().has("name", "marko")).to(__.V().has("name", "vadas"))) }, function({g, xx1}) { return g.E().has("knows", "weight", 1) }], 
     g_addEXedgeX_fromXV_hasXname_markoXX_toXV_hasXname_vadasXX_propertyXweight_0_5X_withXkey_valueX_valuesXweight_keyX: [function({g}) { return g.addV("person").property("name", "marko").property("age", 29).addV("person").property("name", "vadas").property("age", 27) }, function({g}) { return g.addE("edge").from_(__.V().has("name", "marko")).to(__.V().has("name", "vadas")).property("weight", 0.5).with_("key", "value").values("weight", "key") }], 
     g_addEXknowsX_fromXV_hasXname_markoXX_toXV_hasXname_vadasXX_propertyXweight_0_5X_addEXknowsX_fromXV_hasXname_markoXX: [function({g}) { return g.addV("person").property("name", "marko").property("age", 29).addV("person").property("name", "vadas").property("age", 27) }, function({g}) { return g.addE("knows").from_(__.V().has("name", "marko")).to(__.V().has("name", "vadas")).property("weight", 0.5).addE("knows").from_(__.V().has("name", "marko")) }], 
+    g_addEXa_bX_from_V_to_V_labels_fold: [function({g}) { return g.addV("person").property("name", "marko").addV("person").property("name", "josh") }, function({g}) { return g.addE("knows", "trusts").from_(__.V().has("name", "marko")).to(__.V().has("name", "josh")).labels().fold() }, function({g}) { return g.E().hasLabel("knows") }, function({g}) { return g.E().hasLabel("trusts") }], 
+    g_addEXa_b_cX_from_V_to_V_labels_count: [function({g}) { return g.addV("person").property("name", "marko").addV("person").property("name", "josh") }, function({g}) { return g.addE("a", "b", "c").from_(__.V().has("name", "marko")).to(__.V().has("name", "josh")).labels().count() }], 
     g_VX1X_addVXanimalX_propertyXage_selectXaX_byXageXX_propertyXname_puppyX: [function({g, vid1}) { return g.addV("person").property("name", "marko").property("age", 29).as("marko").addV("person").property("name", "vadas").property("age", 27).as("vadas").addV("software").property("name", "lop").property("lang", "java").as("lop").addV("person").property("name", "josh").property("age", 32).as("josh").addV("software").property("name", "ripple").property("lang", "java").as("ripple").addV("p [...]
     g_V_addVXanimalX_propertyXage_0X: [function({g}) { return g.addV("person").property("name", "marko").property("age", 29).as("marko").addV("person").property("name", "vadas").property("age", 27).as("vadas").addV("software").property("name", "lop").property("lang", "java").as("lop").addV("person").property("name", "josh").property("age", 32).as("josh").addV("software").property("name", "ripple").property("lang", "java").as("ripple").addV("person").property("name", "peter").property("ag [...]
     g_V_addVXanimalvarX_propertyXage_0varX: [function({g, xx1, xx2}) { return g.addV("person").property("name", "marko").property("age", 29).as("marko").addV("person").property("name", "vadas").property("age", 27).as("vadas").addV("software").property("name", "lop").property("lang", "java").as("lop").addV("person").property("name", "josh").property("age", 32).as("josh").addV("software").property("name", "ripple").property("lang", "java").as("ripple").addV("person").property("name", "pete [...]
@@ -957,6 +959,8 @@ const gremlins = {
     g_V_limitX3X_addVXsoftwareX_aggregateXa1X_byXlabelX_aggregateXa2X_byXlabelX_capXa1_a2X_selectXa_bX_byXunfoldX_foldX: [function({g}) { return g.addV("person").property("name", "marko").property("age", 29).as("marko").addV("person").property("name", "vadas").property("age", 27).as("vadas").addV("software").property("name", "lop").property("lang", "java").as("lop").addV("person").property("name", "josh").property("age", 32).as("josh").addV("software").property("name", "ripple").property [...]
     g_addV_propertyXname_markoX_withXkey_valueX_valuesXname_keyX: [function({g}) { return g.addV().property("name", "marko").with_("key", "value").values("name", "key") }], 
     g_addV_propertyXname_marko_since_2010X_withXkey_valueX_propertiesXnameX_valuesXsince_keyX: [function({g}) { return g.addV().property("name", "marko", "since", 2010).with_("key", "value").properties("name").values("since", "key") }], 
+    g_addVXa_bX_labels: [function({g}) { return g.addV("a", "b").labels().fold() }, function({g}) { return g.V().hasLabel("a").hasLabel("b") }, function({g}) { return g.addV("a", "b") }, function({g}) { return g.V().labels() }], 
+    g_addVXa_b_cX_labels_count: [function({g}) { return g.addV("a", "b", "c").labels().count() }], 
     g_injectX1X_asBool: [function({g}) { return g.inject(1).asBool() }], 
     g_injectX3_14X_asBool: [function({g}) { return g.inject(3.14).asBool() }], 
     g_injectXneg_1X_asBool: [function({g}) { return g.inject(-1).asBool() }], 
@@ -1251,6 +1255,11 @@ const gremlins = {
     g_injectXListX1_2XX_lTrimXlocalX: [function({g}) { return g.inject([1, 2]).lTrim(Scope.local) }], 
     g_V_valuesXnameX_lTrim: [function({g}) { return g.addV("person").property("name", " marko ").property("age", 29).as("marko").addV("person").property("name", "  vadas  ").property("age", 27).as("vadas").addV("software").property("name", "  lop").property("lang", "java").as("lop").addV("person").property("name", "josh  ").property("age", 32).as("josh").addV("software").property("name", "   ripple   ").property("lang", "java").as("ripple").addV("person").property("name", "peter").proper [...]
     g_V_valuesXnameX_order_fold_lTrimXlocalX: [function({g}) { return g.addV("person").property("name", " marko ").property("age", 29).as("marko").addV("person").property("name", "  vadas  ").property("age", 27).as("vadas").addV("software").property("name", "  lop").property("lang", "java").as("lop").addV("person").property("name", "josh  ").property("age", 32).as("josh").addV("software").property("name", "   ripple   ").property("lang", "java").as("ripple").addV("person").property("name [...]
+    g_V_hasLabelXpersonX_labels: [function({g}) { return g.V().hasLabel("person").labels() }], 
+    g_addVXa_bX_labels_fold: [function({g}) { return g.addV("a", "b") }, function({g}) { return g.V().labels().fold() }], 
+    g_addVXa_bX_labels_count: [function({g}) { return g.addV("a", "b") }, function({g}) { return g.V().labels().count() }], 
+    g_addV_labels: [function({g}) { return g.addV() }, function({g}) { return g.V().labels() }], 
+    g_E_labels: [function({g}) { return g.E().hasLabel("knows").labels() }], 
     g_injectXfeature_test_nullX_length: [function({g}) { return g.inject("feature", "test", null).length() }], 
     g_injectXfeature_test_nullX_lengthXlocalX: [function({g}) { return g.inject("feature", "test", null).length(Scope.local) }], 
     g_injectXListXa_bXX_length: [function({g}) { return g.inject(["a", "b"]).length() }], 
@@ -1492,6 +1501,14 @@ const gremlins = {
     g_mergeV_hidden_label_key_onMatch_matched_prohibited: [function({g, xx1}) { return g.mergeV(new Map([])).option(Merge.onMatch, xx1) }], 
     g_injectXlist1_list2_list3X_fold_asXmX_mergeVXselectXmX_limitXlocal_1X_unfoldX_optionXonCreate_selectXmX_rangeXlocal_1_2X_unfoldX_optionXonMatch_selectXmX_tailXlocalX_unfoldX_to_match: [function({g}) { return g.addV("person").property("name", "marko").property("age", 29) }, function({g}) { return g.inject(new Map([[T.label, "person"], ["name", "marko"]]), new Map([[T.label, "person"], ["name", "marko"]]), new Map([["created", "N"]])).fold().as("m").mergeV(__.select("m").limit(Scope.l [...]
     g_injectXlist1_list2_list3X_fold_asXmX_mergeVXselectXmX_limitXlocal_1X_unfoldX_optionXonCreate_selectXmX_rangeXlocal_1_2X_unfoldX_optionXonMatch_selectXmX_tailXlocalX_unfoldX_to_create: [function({g}) { return g.addV("person").property("name", "marko").property("age", 29) }, function({g}) { return g.inject(new Map([[T.label, "person"], ["name", "stephen"]]), new Map([[T.label, "person"], ["name", "stephen"]]), new Map([["created", "N"]])).fold().as("m").mergeV(__.select("m").limit(Sc [...]
+    g_mergeVXlabel_ab_name_markoX_multilabel_create: [function({g}) { return g.mergeV(new Map([[T.label, ["person", "employee"]], ["name", "marko"]])) }, function({g}) { return g.V() }, function({g}) { return g.V().hasLabel("person").hasLabel("employee") }, function({g}) { return g.V().has("name", "marko") }], 
+    g_mergeVXlabel_abc_name_testX_multilabel_create: [function({g}) { return g.mergeV(new Map([[T.label, ["a", "b", "c"]], ["name", "test"]])) }, function({g}) { return g.V() }, function({g}) { return g.V().hasLabel("a").hasLabel("b").hasLabel("c") }], 
+    g_mergeVXlabel_person_name_markoX_single_label: [function({g}) { return g.mergeV(new Map([[T.label, "person"], ["name", "marko"]])) }, function({g}) { return g.V() }, function({g}) { return g.V().hasLabel("person") }, function({g}) { return g.V().has("name", "marko") }], 
+    g_mergeVXlabel_ab_name_markoX_multilabel_match: [function({g}) { return g.addV("person").addLabel("employee").property("name", "marko") }, function({g}) { return g.mergeV(new Map([[T.label, ["person", "employee"]], ["name", "marko"]])) }, function({g}) { return g.V() }, function({g}) { return g.V().hasLabel("person").hasLabel("employee") }], 
+    g_mergeVXlabel_ab_name_markoX_multilabel_nomatch: [function({g}) { return g.addV("person").property("name", "marko") }, function({g}) { return g.mergeV(new Map([[T.label, ["person", "employee"]], ["name", "marko"]])) }, function({g}) { return g.V() }], 
+    g_mergeVXlabel_person_name_markoX_optionXonMatch_label_managerX: [function({g}) { return g.addV("person").addLabel("employee").property("name", "marko") }, function({g}) { return g.mergeV(new Map([[T.label, "person"], ["name", "marko"]])).option(Merge.onMatch, new Map([[T.label, "manager"]])) }, function({g}) { return g.V() }, function({g}) { return g.V().hasLabel("manager") }, function({g}) { return g.V().hasLabel("person") }, function({g}) { return g.V().hasLabel("employee") }], 
+    g_mergeVXlabel_person_name_markoX_optionXonMatch_label_manager_directorX: [function({g}) { return g.addV("person").property("name", "marko") }, function({g}) { return g.mergeV(new Map([[T.label, "person"], ["name", "marko"]])).option(Merge.onMatch, new Map([[T.label, ["manager", "director"]]])) }, function({g}) { return g.V() }, function({g}) { return g.V().hasLabel("manager").hasLabel("director") }, function({g}) { return g.V().hasLabel("person") }], 
+    g_mergeVXlabel_person_name_markoX_optionXonMatch_label_emptyX: [function({g}) { return g.addV("person").property("name", "marko") }, function({g}) { return g.mergeV(new Map([[T.label, "person"], ["name", "marko"]])).option(Merge.onMatch, new Map([[T.label, []]])) }, function({g}) { return g.V() }, function({g}) { return g.V().hasLabel("vertex") }, function({g}) { return g.V().hasLabel("person") }], 
     g_V_age_min: [function({g}) { return g.V().values("age").min() }], 
     g_V_foo_min: [function({g}) { return g.V().values("foo").min() }], 
     g_V_name_min: [function({g}) { return g.V().values("name").min() }], 
@@ -1977,6 +1994,10 @@ const gremlins = {
     g_V_out_out_properties_asXheadX_path_order_byXdescX_selectXheadX_value: [function({g}) { return g.V().out().out().properties().as("head").path().order().by(Order.desc).select("head").value() }], 
     g_V_out_out_values_asXheadX_path_order_byXascX_selectXheadX: [function({g}) { return g.V().out().out().values().as("head").path().order().by(Order.asc).select("head") }], 
     g_V_out_out_values_asXheadX_path_order_byXdescX_selectXheadX: [function({g}) { return g.V().out().out().values().as("head").path().order().by(Order.desc).select("head") }], 
+    g_V_hasLabelXpersonX_hasXname_markoX_addLabelXemployeeX_labels: [function({g}) { return g.addV("person").property("name", "marko") }, function({g}) { return g.V().hasLabel("person").has("name", "marko").addLabel("employee").labels().fold() }, function({g}) { return g.V().hasLabel("person").hasLabel("employee") }], 
+    g_V_addLabelXa_bX_labels_count: [function({g}) { return g.addV("person") }, function({g}) { return g.V().addLabel("a", "b").labels().count() }], 
+    g_V_addLabelXexistingX_labels_count: [function({g}) { return g.addV("person") }, function({g}) { return g.V().addLabel("person").labels().count() }], 
+    g_E_addLabelXfriendX_labels_fold: [function({g}) { return g.addV("person").property("name", "marko").as("a").addV("person").property("name", "josh").as("b").addE("knows").from_("a").to("b") }, function({g}) { return g.E().addLabel("friend").labels().fold() }, function({g}) { return g.E().hasLabel("knows") }, function({g}) { return g.E().hasLabel("friend") }], 
     g_V_valueXnameX_aggregateXxX_capXxX: [function({g}) { return g.V().values("name").aggregate("x").cap("x") }], 
     g_V_aggregateXxX_byXnameX_capXxX: [function({g}) { return g.V().aggregate("x").by("name").cap("x") }], 
     g_V_out_aggregateXaX_path: [function({g}) { return g.V().out().aggregate("a").path() }], 
@@ -2034,6 +2055,12 @@ const gremlins = {
     g_V_repeatXaggregateXaXX_timesX2X_capXaX_unfold: [function({g}) { return g.V().repeat(__.aggregate("a")).times(2).cap("a").unfold() }], 
     g_V_aggregateXaX_capXaX_unfold_both: [function({g}) { return g.V().aggregate("a").cap("a").unfold().both() }], 
     g_V_aggregateXaX_capXaX_unfold_barrier_both: [function({g}) { return g.V().aggregate("a").cap("a").unfold().barrier().both() }], 
+    g_V_dropLabelXaX_labels: [function({g}) { return g.addV("a", "b") }, function({g}) { return g.V().dropLabel("a").labels().fold() }, function({g}) { return g.V().hasLabel("a") }, function({g}) { return g.V().hasLabel("b") }], 
+    g_V_dropLabels_labels: [function({g}) { return g.addV("a", "b") }, function({g}) { return g.V().dropLabels().labels() }], 
+    g_V_dropLabelXa_bX_labels: [function({g}) { return g.addV("a", "b", "c") }, function({g}) { return g.V().dropLabel("a", "b").labels() }], 
+    g_V_dropLabels_defaultLabel: [function({g}) { return g.addV("person") }, function({g}) { return g.V().dropLabels().labels() }], 
+    g_E_dropLabelXknowsX_labels: [function({g}) { return g.addV("person").as("a").addV("person").as("b").addE("knows", "trusts").from_("a").to("b") }, function({g}) { return g.E().dropLabel("knows").labels().fold() }, function({g}) { return g.E().hasLabel("knows") }, function({g}) { return g.E().hasLabel("trusts") }], 
+    g_E_dropLabels_labels: [function({g}) { return g.addV("person").as("a").addV("person").as("b").addE("knows", "trusts").from_("a").to("b") }, function({g}) { return g.E().dropLabels().labels() }], 
     g_V_fail: [function({g}) { return g.V().fail() }], 
     g_V_failXmsgX: [function({g}) { return g.V().fail("msg") }], 
     g_V_unionXout_failX: [function({g}) { return g.V().union(__.out(), __.fail()) }], 
diff --git a/gremlin-js/gremlin-mcp/src/translator/stepNames.ts b/gremlin-js/gremlin-mcp/src/translator/stepNames.ts
index 3873293afd..71525a298b 100644
--- a/gremlin-js/gremlin-mcp/src/translator/stepNames.ts
+++ b/gremlin-js/gremlin-mcp/src/translator/stepNames.ts
@@ -28,6 +28,7 @@ export const GREMLIN_STEP_NAMES: ReadonlySet<string> = new Set([
   'E',
   'V',
   'addE',
+  'addLabel',
   'addV',
   'aggregate',
   'all',
@@ -62,6 +63,8 @@ export const GREMLIN_STEP_NAMES: ReadonlySet<string> = new Set([
   'discard',
   'disjunct',
   'drop',
+  'dropLabel',
+  'dropLabels',
   'element',
   'elementMap',
   'emit',
@@ -92,6 +95,7 @@ export const GREMLIN_STEP_NAMES: ReadonlySet<string> = new Set([
   'key',
   'lTrim',
   'label',
+  'labels',
   'length',
   'limit',
   'local',
@@ -170,6 +174,7 @@ export const GREMLIN_STEP_NAMES_PASCAL: ReadonlySet<string> = new Set([
   'E',
   'V',
   'AddE',
+  'AddLabel',
   'AddV',
   'Aggregate',
   'All',
@@ -204,6 +209,8 @@ export const GREMLIN_STEP_NAMES_PASCAL: ReadonlySet<string> = new Set([
   'Discard',
   'Disjunct',
   'Drop',
+  'DropLabel',
+  'DropLabels',
   'Element',
   'ElementMap',
   'Emit',
@@ -234,6 +241,7 @@ export const GREMLIN_STEP_NAMES_PASCAL: ReadonlySet<string> = new Set([
   'Key',
   'LTrim',
   'Label',
+  'Labels',
   'Length',
   'Limit',
   'Local',
diff --git a/gremlin-python/src/main/python/gremlin_python/process/graph_traversal.py b/gremlin-python/src/main/python/gremlin_python/process/graph_traversal.py
index 082df46d1a..70453100a5 100644
--- a/gremlin-python/src/main/python/gremlin_python/process/graph_traversal.py
+++ b/gremlin-python/src/main/python/gremlin_python/process/graph_traversal.py
@@ -296,6 +296,17 @@ class GraphTraversal(Traversal):
         self.gremlin_lang.add_step("addV", *args)
         return self
 
+    def addLabel(self, *args):
+        warnings.warn(
+            "gremlin_python.process.GraphTraversal.addLabel will be replaced by "
+            "gremlin_python.process.GraphTraversal.add_label.",
+            DeprecationWarning)
+        return self.add_label(*args)
+
+    def add_label(self, *args):
+        self.gremlin_lang.add_step("addLabel", *args)
+        return self
+
     def aggregate(self, *args):
         self.gremlin_lang.add_step("aggregate", *args)
         return self
@@ -460,6 +471,28 @@ class GraphTraversal(Traversal):
         self.gremlin_lang.add_step("drop", *args)
         return self
 
+    def dropLabel(self, *args):
+        warnings.warn(
+            "gremlin_python.process.GraphTraversal.dropLabel will be replaced by "
+            "gremlin_python.process.GraphTraversal.drop_label.",
+            DeprecationWarning)
+        return self.drop_label(*args)
+
+    def drop_label(self, *args):
+        self.gremlin_lang.add_step("dropLabel", *args)
+        return self
+
+    def dropLabels(self, *args):
+        warnings.warn(
+            "gremlin_python.process.GraphTraversal.dropLabels will be replaced by "
+            "gremlin_python.process.GraphTraversal.drop_labels.",
+            DeprecationWarning)
+        return self.drop_labels(*args)
+
+    def drop_labels(self, *args):
+        self.gremlin_lang.add_step("dropLabels", *args)
+        return self
+
     def element(self, *args):
         self.gremlin_lang.add_step("element", *args)
         return self
@@ -652,6 +685,10 @@ class GraphTraversal(Traversal):
         self.gremlin_lang.add_step("label", *args)
         return self
 
+    def labels(self, *args):
+        self.gremlin_lang.add_step("labels", *args)
+        return self
+
     def length(self, *args):
         self.gremlin_lang.add_step("length", *args)
         return self
@@ -1087,6 +1124,18 @@ class __(object, metaclass=MagicType):
     def add_v(cls, *args):
         return cls.graph_traversal(None, None, GremlinLang()).add_v(*args)
 
+    @classmethod
+    def addLabel(cls, *args):
+        warnings.warn(
+            "gremlin_python.process.__.addLabel will be replaced by "
+            "gremlin_python.process.__.add_label.",
+            DeprecationWarning)
+        return cls.add_label(*args)
+
+    @classmethod
+    def add_label(cls, *args):
+        return cls.graph_traversal(None, None, GremlinLang()).add_label(*args)
+
     @classmethod
     def aggregate(cls, *args):
         return cls.graph_traversal(None, None, GremlinLang()).aggregate(*args)
@@ -1239,6 +1288,30 @@ class __(object, metaclass=MagicType):
     def drop(cls, *args):
         return cls.graph_traversal(None, None, GremlinLang()).drop(*args)
 
+    @classmethod
+    def dropLabel(cls, *args):
+        warnings.warn(
+            "gremlin_python.process.__.dropLabel will be replaced by "
+            "gremlin_python.process.__.drop_label.",
+            DeprecationWarning)
+        return cls.drop_label(*args)
+
+    @classmethod
+    def drop_label(cls, *args):
+        return cls.graph_traversal(None, None, GremlinLang()).drop_label(*args)
+
+    @classmethod
+    def dropLabels(cls, *args):
+        warnings.warn(
+            "gremlin_python.process.__.dropLabels will be replaced by "
+            "gremlin_python.process.__.drop_labels.",
+            DeprecationWarning)
+        return cls.drop_labels(*args)
+
+    @classmethod
+    def drop_labels(cls, *args):
+        return cls.graph_traversal(None, None, GremlinLang()).drop_labels(*args)
+
     @classmethod
     def element(cls, *args):
         return cls.graph_traversal(None, None, GremlinLang()).element(*args)
@@ -1435,6 +1508,10 @@ class __(object, metaclass=MagicType):
     def label(cls, *args):
         return cls.graph_traversal(None, None, GremlinLang()).label(*args)
 
+    @classmethod
+    def labels(cls, *args):
+        return cls.graph_traversal(None, None, GremlinLang()).labels(*args)
+
     @classmethod
     def length(cls, *args):
         return cls.graph_traversal(None, None, GremlinLang()).length(*args)
@@ -1875,6 +1952,14 @@ def add_v(*args):
     return __.add_v(*args)
 
 
+def addLabel(*args):
+    return __.add_label(*args)
+
+
+def add_label(*args):
+    return __.add_label(*args)
+
+
 def aggregate(*args):
     return __.aggregate(*args)
 
@@ -2015,6 +2100,22 @@ def drop(*args):
     return __.drop(*args)
 
 
+def dropLabel(*args):
+    return __.drop_label(*args)
+
+
+def drop_label(*args):
+    return __.drop_label(*args)
+
+
+def dropLabels(*args):
+    return __.drop_labels(*args)
+
+
+def drop_labels(*args):
+    return __.drop_labels(*args)
+
+
 def element(*args):
     return __.element(*args)
 
@@ -2165,6 +2266,10 @@ def label(*args):
     return __.label(*args)
 
 
+def labels(*args):
+    return __.labels(*args)
+
+
 def length(*args):
     return __.length(*args)
 
@@ -2468,6 +2573,10 @@ statics.add_static('addV', addV)
 
 statics.add_static('add_v', add_v)
 
+statics.add_static('addLabel', addLabel)
+
+statics.add_static('add_label', add_label)
+
 statics.add_static('aggregate', aggregate)
 
 statics.add_static('all_', all_)
@@ -2538,6 +2647,14 @@ statics.add_static('disjunct', disjunct)
 
 statics.add_static('drop', drop)
 
+statics.add_static('dropLabel', dropLabel)
+
+statics.add_static('drop_label', drop_label)
+
+statics.add_static('dropLabels', dropLabels)
+
+statics.add_static('drop_labels', drop_labels)
+
 statics.add_static('element', element)
 
 statics.add_static('elementMap', elementMap)
@@ -2610,6 +2727,8 @@ statics.add_static('key', key)
 
 statics.add_static('label', label)
 
+statics.add_static('labels', labels)
+
 statics.add_static('length', length)
 
 statics.add_static('limit', limit)
diff --git a/gremlin-python/src/main/python/gremlin_python/structure/graph.py b/gremlin-python/src/main/python/gremlin_python/structure/graph.py
index 61f92c3065..bc60be5f5b 100644
--- a/gremlin-python/src/main/python/gremlin_python/structure/graph.py
+++ b/gremlin-python/src/main/python/gremlin_python/structure/graph.py
@@ -64,19 +64,37 @@ class Element(object):
 
 
 class Vertex(Element):
-    def __init__(self, id, label="vertex", properties=None):
-        Element.__init__(self, id, label, properties)
+    def __init__(self, id, label="vertex", properties=None, labels=None):
+        if labels is not None and len(labels) > 0:
+            self._labels = set(labels)
+            Element.__init__(self, id, next(iter(labels)), properties)
+        else:
+            self._labels = {label} if label else {"vertex"}
+            Element.__init__(self, id, label or "vertex", properties)
+
+    @property
+    def labels(self):
+        return frozenset(self._labels)
 
     def __repr__(self):
         return "v[" + str(self.id) + "]"
 
 
 class Edge(Element):
-    def __init__(self, id, outV, label, inV, properties=None):
-        Element.__init__(self, id, label, properties)
+    def __init__(self, id, outV, label, inV, properties=None, labels=None):
+        if labels is not None and len(labels) > 0:
+            self._labels = set(labels)
+            Element.__init__(self, id, next(iter(labels)), properties)
+        else:
+            self._labels = {label} if label else {"edge"}
+            Element.__init__(self, id, label or "edge", properties)
         self.outV = outV
         self.inV = inV
 
+    @property
+    def labels(self):
+        return frozenset(self._labels)
+
     def __repr__(self):
         return "e[" + str(self.id) + "][" + str(self.outV.id) + "-" + self.label + "->" + str(self.inV.id) + "]"
 
diff --git a/gremlin-python/src/main/python/gremlin_python/structure/io/graphbinaryV4.py b/gremlin-python/src/main/python/gremlin_python/structure/io/graphbinaryV4.py
index 4cdc3a14ee..5398a6a9e0 100644
--- a/gremlin-python/src/main/python/gremlin_python/structure/io/graphbinaryV4.py
+++ b/gremlin-python/src/main/python/gremlin_python/structure/io/graphbinaryV4.py
@@ -568,12 +568,21 @@ class EdgeIO(_GraphBinaryTypeIO):
         cls.prefix_bytes(cls.graphbinary_type, as_value, nullable, to_extend)
 
         writer.to_dict(obj.id, to_extend)
-        # serializing label as list here for now according to GraphBinaryV4
-        ListIO.dictify([obj.label], writer, to_extend, True, False)
+        # serializing labels as list according to GraphBinaryV4
+        if hasattr(obj, '_labels') and obj._labels:
+            ListIO.dictify(list(obj._labels), writer, to_extend, True, False)
+        else:
+            ListIO.dictify([obj.label], writer, to_extend, True, False)
         writer.to_dict(obj.inV.id, to_extend)
-        ListIO.dictify([obj.inV.label], writer, to_extend, True, False)
+        if hasattr(obj.inV, '_labels') and obj.inV._labels:
+            ListIO.dictify(list(obj.inV._labels), writer, to_extend, True, False)
+        else:
+            ListIO.dictify([obj.inV.label], writer, to_extend, True, False)
         writer.to_dict(obj.outV.id, to_extend)
-        ListIO.dictify([obj.outV.label], writer, to_extend, True, False)
+        if hasattr(obj.outV, '_labels') and obj.outV._labels:
+            ListIO.dictify(list(obj.outV._labels), writer, to_extend, True, False)
+        else:
+            ListIO.dictify([obj.outV.label], writer, to_extend, True, False)
         to_extend.extend(NULL_BYTES)
         to_extend.extend(NULL_BYTES)
 
@@ -586,15 +595,15 @@ class EdgeIO(_GraphBinaryTypeIO):
     @classmethod
     def _read_edge(cls, b, r):
         edgeid = r.read_object(b)
-        # reading single string value for now according to GraphBinaryV4
-        edgelbl = r.to_object(b, DataType.list, False)[0]
+        # reading label list according to GraphBinaryV4
+        edge_labels = r.to_object(b, DataType.list, False)
         inv = Vertex(r.read_object(b), r.to_object(b, DataType.list, False)[0])
         outv = Vertex(r.read_object(b), r.to_object(b, DataType.list, False)[0])
         b.read(2)
         props = r.read_object(b)
         # null properties are returned as empty lists
         properties = [] if props is None else props
-        edge = Edge(edgeid, outv, edgelbl, inv, properties)
+        edge = Edge(edgeid, outv, edge_labels[0] if edge_labels else "edge", inv, properties, labels=edge_labels)
         return edge
 
 
@@ -654,7 +663,10 @@ class TinkerGraphIO(_GraphBinaryTypeIO):
         IntIO.dictify(len(vertices), writer, to_extend, True, False)
         for v in vertices:
             writer.to_dict(v.id, to_extend)
-            ListIO.dictify([v.label], writer, to_extend, True, False)
+            if hasattr(v, '_labels') and v._labels:
+                ListIO.dictify(list(v._labels), writer, to_extend, True, False)
+            else:
+                ListIO.dictify([v.label], writer, to_extend, True, False)
             v_props = v.properties
             IntIO.dictify(len(v_props), writer, to_extend, True, False)
             for vp in v_props:
@@ -667,7 +679,10 @@ class TinkerGraphIO(_GraphBinaryTypeIO):
         IntIO.dictify(len(edges), writer, to_extend, True, False)
         for e in edges:
             writer.to_dict(e.id, to_extend)
-            ListIO.dictify([e.label], writer, to_extend, True, False)
+            if hasattr(e, '_labels') and e._labels:
+                ListIO.dictify(list(e._labels), writer, to_extend, True, False)
+            else:
+                ListIO.dictify([e.label], writer, to_extend, True, False)
             writer.to_dict(e.inV.id, to_extend)
             writer.to_dict(None, to_extend)
             writer.to_dict(e.outV.id, to_extend)
@@ -687,8 +702,8 @@ class TinkerGraphIO(_GraphBinaryTypeIO):
         vertex_count = r.to_object(b, DataType.int, False)
         for _ in range(vertex_count):
             v_id = r.read_object(b)
-            v_label = r.to_object(b, DataType.list, False)[0]
-            vertex = Vertex(v_id, v_label)
+            v_labels = r.to_object(b, DataType.list, False)
+            vertex = Vertex(v_id, v_labels[0] if v_labels else "vertex", labels=v_labels)
             graph.vertices[v_id] = vertex
 
             vp_count = r.to_object(b, DataType.int, False)
@@ -707,14 +722,15 @@ class TinkerGraphIO(_GraphBinaryTypeIO):
         edge_count = r.to_object(b, DataType.int, False)
         for _ in range(edge_count):
             e_id = r.read_object(b)
-            e_label = r.to_object(b, DataType.list, False)[0]
+            e_labels = r.to_object(b, DataType.list, False)
             in_v_id = r.read_object(b)
             r.read_object(b)  # discard in-v label
             out_v_id = r.read_object(b)
             r.read_object(b)  # discard out-v label
             r.read_object(b)  # discard parent
 
-            edge = Edge(e_id, graph.vertices[out_v_id], e_label, graph.vertices[in_v_id])
+            edge = Edge(e_id, graph.vertices[out_v_id], e_labels[0] if e_labels else "edge",
+                        graph.vertices[in_v_id], labels=e_labels)
             graph.edges[e_id] = edge
 
             edge_props = r.to_object(b, DataType.list, False)
@@ -733,8 +749,11 @@ class VertexIO(_GraphBinaryTypeIO):
     def dictify(cls, obj, writer, to_extend, as_value=False, nullable=True):
         cls.prefix_bytes(cls.graphbinary_type, as_value, nullable, to_extend)
         writer.to_dict(obj.id, to_extend)
-        # serializing label as list here for now according to GraphBinaryV4
-        ListIO.dictify([obj.label], writer, to_extend, True, False)
+        # serializing labels as list according to GraphBinaryV4
+        if hasattr(obj, '_labels') and obj._labels:
+            ListIO.dictify(list(obj._labels), writer, to_extend, True, False)
+        else:
+            ListIO.dictify([obj.label], writer, to_extend, True, False)
         to_extend.extend(NULL_BYTES)
         return to_extend
 
@@ -745,12 +764,12 @@ class VertexIO(_GraphBinaryTypeIO):
     @classmethod
     def _read_vertex(cls, b, r):
         vertex_id = r.read_object(b)
-        # reading single string value for now according to GraphBinaryV4
-        vertex_label = r.to_object(b, DataType.list, False)[0]
+        # reading label list according to GraphBinaryV4
+        vertex_labels = r.to_object(b, DataType.list, False)
         props = r.read_object(b)
         # null properties are returned as empty lists
         properties = [] if props is None else props
-        vertex = Vertex(vertex_id, vertex_label, properties)
+        vertex = Vertex(vertex_id, vertex_labels[0] if vertex_labels else "vertex", properties, labels=vertex_labels)
         return vertex
 
 
diff --git a/gremlin-python/src/main/python/tests/feature/gremlin.py b/gremlin-python/src/main/python/tests/feature/gremlin.py
index 8dd5394e02..3c9709c755 100644
--- a/gremlin-python/src/main/python/tests/feature/gremlin.py
+++ b/gremlin-python/src/main/python/tests/feature/gremlin.py
@@ -896,6 +896,8 @@ world.gremlins = {
     'g_unionXaddEXknowsvarXpropertyXweight_nullXfromXV_hasXname_markoXX_toXV_hasXname_vadasXXX': [(lambda g, xx1=None:g.add_v('person').property('name', 'marko').property('age', 29).add_v('person').property('name', 'vadas').property('age', 27)), (lambda g, xx1=None:g.union(__.add_e(xx1).property('weight', 1).from_(__.V().has('name', 'marko')).to(__.V().has('name', 'vadas')))), (lambda g, xx1=None:g.E().has('knows', 'weight', 1))], 
     'g_addEXedgeX_fromXV_hasXname_markoXX_toXV_hasXname_vadasXX_propertyXweight_0_5X_withXkey_valueX_valuesXweight_keyX': [(lambda g:g.add_v('person').property('name', 'marko').property('age', 29).add_v('person').property('name', 'vadas').property('age', 27)), (lambda g:g.add_e('edge').from_(__.V().has('name', 'marko')).to(__.V().has('name', 'vadas')).property('weight', 0.5).with_('key', 'value').values('weight', 'key'))], 
     'g_addEXknowsX_fromXV_hasXname_markoXX_toXV_hasXname_vadasXX_propertyXweight_0_5X_addEXknowsX_fromXV_hasXname_markoXX': [(lambda g:g.add_v('person').property('name', 'marko').property('age', 29).add_v('person').property('name', 'vadas').property('age', 27)), (lambda g:g.add_e('knows').from_(__.V().has('name', 'marko')).to(__.V().has('name', 'vadas')).property('weight', 0.5).add_e('knows').from_(__.V().has('name', 'marko')))], 
+    'g_addEXa_bX_from_V_to_V_labels_fold': [(lambda g:g.add_v('person').property('name', 'marko').add_v('person').property('name', 'josh')), (lambda g:g.add_e('knows', 'trusts').from_(__.V().has('name', 'marko')).to(__.V().has('name', 'josh')).labels().fold()), (lambda g:g.E().has_label('knows')), (lambda g:g.E().has_label('trusts'))], 
+    'g_addEXa_b_cX_from_V_to_V_labels_count': [(lambda g:g.add_v('person').property('name', 'marko').add_v('person').property('name', 'josh')), (lambda g:g.add_e('a', 'b', 'c').from_(__.V().has('name', 'marko')).to(__.V().has('name', 'josh')).labels().count())], 
     'g_VX1X_addVXanimalX_propertyXage_selectXaX_byXageXX_propertyXname_puppyX': [(lambda g, vid1=None:g.add_v('person').property('name', 'marko').property('age', 29).as_('marko').add_v('person').property('name', 'vadas').property('age', 27).as_('vadas').add_v('software').property('name', 'lop').property('lang', 'java').as_('lop').add_v('person').property('name', 'josh').property('age', 32).as_('josh').add_v('software').property('name', 'ripple').property('lang', 'java').as_('ripple').add [...]
     'g_V_addVXanimalX_propertyXage_0X': [(lambda g:g.add_v('person').property('name', 'marko').property('age', 29).as_('marko').add_v('person').property('name', 'vadas').property('age', 27).as_('vadas').add_v('software').property('name', 'lop').property('lang', 'java').as_('lop').add_v('person').property('name', 'josh').property('age', 32).as_('josh').add_v('software').property('name', 'ripple').property('lang', 'java').as_('ripple').add_v('person').property('name', 'peter').property('ag [...]
     'g_V_addVXanimalvarX_propertyXage_0varX': [(lambda g, xx1=None,xx2=None:g.add_v('person').property('name', 'marko').property('age', 29).as_('marko').add_v('person').property('name', 'vadas').property('age', 27).as_('vadas').add_v('software').property('name', 'lop').property('lang', 'java').as_('lop').add_v('person').property('name', 'josh').property('age', 32).as_('josh').add_v('software').property('name', 'ripple').property('lang', 'java').as_('ripple').add_v('person').property('nam [...]
@@ -931,6 +933,8 @@ world.gremlins = {
     'g_V_limitX3X_addVXsoftwareX_aggregateXa1X_byXlabelX_aggregateXa2X_byXlabelX_capXa1_a2X_selectXa_bX_byXunfoldX_foldX': [(lambda g:g.add_v('person').property('name', 'marko').property('age', 29).as_('marko').add_v('person').property('name', 'vadas').property('age', 27).as_('vadas').add_v('software').property('name', 'lop').property('lang', 'java').as_('lop').add_v('person').property('name', 'josh').property('age', 32).as_('josh').add_v('software').property('name', 'ripple').property(' [...]
     'g_addV_propertyXname_markoX_withXkey_valueX_valuesXname_keyX': [(lambda g:g.add_v().property('name', 'marko').with_('key', 'value').values('name', 'key'))], 
     'g_addV_propertyXname_marko_since_2010X_withXkey_valueX_propertiesXnameX_valuesXsince_keyX': [(lambda g:g.add_v().property('name', 'marko', 'since', 2010).with_('key', 'value').properties('name').values('since', 'key'))], 
+    'g_addVXa_bX_labels': [(lambda g:g.add_v('a', 'b').labels().fold()), (lambda g:g.V().has_label('a').has_label('b')), (lambda g:g.add_v('a', 'b')), (lambda g:g.V().labels())], 
+    'g_addVXa_b_cX_labels_count': [(lambda g:g.add_v('a', 'b', 'c').labels().count())], 
     'g_injectX1X_asBool': [(lambda g:g.inject(1).as_bool())], 
     'g_injectX3_14X_asBool': [(lambda g:g.inject(3.14).as_bool())], 
     'g_injectXneg_1X_asBool': [(lambda g:g.inject(-1).as_bool())], 
@@ -1225,6 +1229,11 @@ world.gremlins = {
     'g_injectXListX1_2XX_lTrimXlocalX': [(lambda g:g.inject([1, 2]).l_trim(Scope.local))], 
     'g_V_valuesXnameX_lTrim': [(lambda g:g.add_v('person').property('name', ' marko ').property('age', 29).as_('marko').add_v('person').property('name', '  vadas  ').property('age', 27).as_('vadas').add_v('software').property('name', '  lop').property('lang', 'java').as_('lop').add_v('person').property('name', 'josh  ').property('age', 32).as_('josh').add_v('software').property('name', '   ripple   ').property('lang', 'java').as_('ripple').add_v('person').property('name', 'peter').proper [...]
     'g_V_valuesXnameX_order_fold_lTrimXlocalX': [(lambda g:g.add_v('person').property('name', ' marko ').property('age', 29).as_('marko').add_v('person').property('name', '  vadas  ').property('age', 27).as_('vadas').add_v('software').property('name', '  lop').property('lang', 'java').as_('lop').add_v('person').property('name', 'josh  ').property('age', 32).as_('josh').add_v('software').property('name', '   ripple   ').property('lang', 'java').as_('ripple').add_v('person').property('name [...]
+    'g_V_hasLabelXpersonX_labels': [(lambda g:g.V().has_label('person').labels())], 
+    'g_addVXa_bX_labels_fold': [(lambda g:g.add_v('a', 'b')), (lambda g:g.V().labels().fold())], 
+    'g_addVXa_bX_labels_count': [(lambda g:g.add_v('a', 'b')), (lambda g:g.V().labels().count())], 
+    'g_addV_labels': [(lambda g:g.add_v()), (lambda g:g.V().labels())], 
+    'g_E_labels': [(lambda g:g.E().has_label('knows').labels())], 
     'g_injectXfeature_test_nullX_length': [(lambda g:g.inject('feature', 'test', None).length())], 
     'g_injectXfeature_test_nullX_lengthXlocalX': [(lambda g:g.inject('feature', 'test', None).length(Scope.local))], 
     'g_injectXListXa_bXX_length': [(lambda g:g.inject(['a', 'b']).length())], 
@@ -1466,6 +1475,14 @@ world.gremlins = {
     'g_mergeV_hidden_label_key_onMatch_matched_prohibited': [(lambda g, xx1=None:g.merge_v({  }).option(Merge.on_match, xx1))], 
     'g_injectXlist1_list2_list3X_fold_asXmX_mergeVXselectXmX_limitXlocal_1X_unfoldX_optionXonCreate_selectXmX_rangeXlocal_1_2X_unfoldX_optionXonMatch_selectXmX_tailXlocalX_unfoldX_to_match': [(lambda g:g.add_v('person').property('name', 'marko').property('age', 29)), (lambda g:g.inject({ T.label: 'person', 'name': 'marko' }, { T.label: 'person', 'name': 'marko' }, { 'created': 'N' }).fold().as_('m').merge_v(__.select('m').limit(Scope.local, 1).unfold()).option(Merge.on_create, __.select( [...]
     'g_injectXlist1_list2_list3X_fold_asXmX_mergeVXselectXmX_limitXlocal_1X_unfoldX_optionXonCreate_selectXmX_rangeXlocal_1_2X_unfoldX_optionXonMatch_selectXmX_tailXlocalX_unfoldX_to_create': [(lambda g:g.add_v('person').property('name', 'marko').property('age', 29)), (lambda g:g.inject({ T.label: 'person', 'name': 'stephen' }, { T.label: 'person', 'name': 'stephen' }, { 'created': 'N' }).fold().as_('m').merge_v(__.select('m').limit(Scope.local, 1).unfold()).option(Merge.on_create, __.se [...]
+    'g_mergeVXlabel_ab_name_markoX_multilabel_create': [(lambda g:g.merge_v({ T.label: ['person', 'employee'], 'name': 'marko' })), (lambda g:g.V()), (lambda g:g.V().has_label('person').has_label('employee')), (lambda g:g.V().has('name', 'marko'))], 
+    'g_mergeVXlabel_abc_name_testX_multilabel_create': [(lambda g:g.merge_v({ T.label: ['a', 'b', 'c'], 'name': 'test' })), (lambda g:g.V()), (lambda g:g.V().has_label('a').has_label('b').has_label('c'))], 
+    'g_mergeVXlabel_person_name_markoX_single_label': [(lambda g:g.merge_v({ T.label: 'person', 'name': 'marko' })), (lambda g:g.V()), (lambda g:g.V().has_label('person')), (lambda g:g.V().has('name', 'marko'))], 
+    'g_mergeVXlabel_ab_name_markoX_multilabel_match': [(lambda g:g.add_v('person').add_label('employee').property('name', 'marko')), (lambda g:g.merge_v({ T.label: ['person', 'employee'], 'name': 'marko' })), (lambda g:g.V()), (lambda g:g.V().has_label('person').has_label('employee'))], 
+    'g_mergeVXlabel_ab_name_markoX_multilabel_nomatch': [(lambda g:g.add_v('person').property('name', 'marko')), (lambda g:g.merge_v({ T.label: ['person', 'employee'], 'name': 'marko' })), (lambda g:g.V())], 
+    'g_mergeVXlabel_person_name_markoX_optionXonMatch_label_managerX': [(lambda g:g.add_v('person').add_label('employee').property('name', 'marko')), (lambda g:g.merge_v({ T.label: 'person', 'name': 'marko' }).option(Merge.on_match, { T.label: 'manager' })), (lambda g:g.V()), (lambda g:g.V().has_label('manager')), (lambda g:g.V().has_label('person')), (lambda g:g.V().has_label('employee'))], 
+    'g_mergeVXlabel_person_name_markoX_optionXonMatch_label_manager_directorX': [(lambda g:g.add_v('person').property('name', 'marko')), (lambda g:g.merge_v({ T.label: 'person', 'name': 'marko' }).option(Merge.on_match, { T.label: ['manager', 'director'] })), (lambda g:g.V()), (lambda g:g.V().has_label('manager').has_label('director')), (lambda g:g.V().has_label('person'))], 
+    'g_mergeVXlabel_person_name_markoX_optionXonMatch_label_emptyX': [(lambda g:g.add_v('person').property('name', 'marko')), (lambda g:g.merge_v({ T.label: 'person', 'name': 'marko' }).option(Merge.on_match, { T.label: [] })), (lambda g:g.V()), (lambda g:g.V().has_label('vertex')), (lambda g:g.V().has_label('person'))], 
     'g_V_age_min': [(lambda g:g.V().values('age').min_())], 
     'g_V_foo_min': [(lambda g:g.V().values('foo').min_())], 
     'g_V_name_min': [(lambda g:g.V().values('name').min_())], 
@@ -1951,6 +1968,10 @@ world.gremlins = {
     'g_V_out_out_properties_asXheadX_path_order_byXdescX_selectXheadX_value': [(lambda g:g.V().out().out().properties().as_('head').path().order().by(Order.desc).select('head').value())], 
     'g_V_out_out_values_asXheadX_path_order_byXascX_selectXheadX': [(lambda g:g.V().out().out().values().as_('head').path().order().by(Order.asc).select('head'))], 
     'g_V_out_out_values_asXheadX_path_order_byXdescX_selectXheadX': [(lambda g:g.V().out().out().values().as_('head').path().order().by(Order.desc).select('head'))], 
+    'g_V_hasLabelXpersonX_hasXname_markoX_addLabelXemployeeX_labels': [(lambda g:g.add_v('person').property('name', 'marko')), (lambda g:g.V().has_label('person').has('name', 'marko').add_label('employee').labels().fold()), (lambda g:g.V().has_label('person').has_label('employee'))], 
+    'g_V_addLabelXa_bX_labels_count': [(lambda g:g.add_v('person')), (lambda g:g.V().add_label('a', 'b').labels().count())], 
+    'g_V_addLabelXexistingX_labels_count': [(lambda g:g.add_v('person')), (lambda g:g.V().add_label('person').labels().count())], 
+    'g_E_addLabelXfriendX_labels_fold': [(lambda g:g.add_v('person').property('name', 'marko').as_('a').add_v('person').property('name', 'josh').as_('b').add_e('knows').from_('a').to('b')), (lambda g:g.E().add_label('friend').labels().fold()), (lambda g:g.E().has_label('knows')), (lambda g:g.E().has_label('friend'))], 
     'g_V_valueXnameX_aggregateXxX_capXxX': [(lambda g:g.V().values('name').aggregate('x').cap('x'))], 
     'g_V_aggregateXxX_byXnameX_capXxX': [(lambda g:g.V().aggregate('x').by('name').cap('x'))], 
     'g_V_out_aggregateXaX_path': [(lambda g:g.V().out().aggregate('a').path())], 
@@ -2008,6 +2029,12 @@ world.gremlins = {
     'g_V_repeatXaggregateXaXX_timesX2X_capXaX_unfold': [(lambda g:g.V().repeat(__.aggregate('a')).times(2).cap('a').unfold())], 
     'g_V_aggregateXaX_capXaX_unfold_both': [(lambda g:g.V().aggregate('a').cap('a').unfold().both())], 
     'g_V_aggregateXaX_capXaX_unfold_barrier_both': [(lambda g:g.V().aggregate('a').cap('a').unfold().barrier().both())], 
+    'g_V_dropLabelXaX_labels': [(lambda g:g.add_v('a', 'b')), (lambda g:g.V().drop_label('a').labels().fold()), (lambda g:g.V().has_label('a')), (lambda g:g.V().has_label('b'))], 
+    'g_V_dropLabels_labels': [(lambda g:g.add_v('a', 'b')), (lambda g:g.V().drop_labels().labels())], 
+    'g_V_dropLabelXa_bX_labels': [(lambda g:g.add_v('a', 'b', 'c')), (lambda g:g.V().drop_label('a', 'b').labels())], 
+    'g_V_dropLabels_defaultLabel': [(lambda g:g.add_v('person')), (lambda g:g.V().drop_labels().labels())], 
+    'g_E_dropLabelXknowsX_labels': [(lambda g:g.add_v('person').as_('a').add_v('person').as_('b').add_e('knows', 'trusts').from_('a').to('b')), (lambda g:g.E().drop_label('knows').labels().fold()), (lambda g:g.E().has_label('knows')), (lambda g:g.E().has_label('trusts'))], 
+    'g_E_dropLabels_labels': [(lambda g:g.add_v('person').as_('a').add_v('person').as_('b').add_e('knows', 'trusts').from_('a').to('b')), (lambda g:g.E().drop_labels().labels())], 
     'g_V_fail': [(lambda g:g.V().fail())], 
     'g_V_failXmsgX': [(lambda g:g.V().fail('msg'))], 
     'g_V_unionXout_failX': [(lambda g:g.V().union(__.out(), __.fail()))], 
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/language/translator/translations.json b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/language/translator/translations.json
index c420bd491f..7de3961add 100644
--- a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/language/translator/translations.json
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/language/translator/translations.json
@@ -17831,6 +17831,88 @@
             }
         ]
     },
+    {
+        "scenario": "g_addEXa_bX_from_V_to_V_labels_fold",
+        "traversals": [
+            {
+                "original": "g.addV(\"person\").property(\"name\", \"marko\").addV(\"person\").property(\"name\", \"josh\")",
+                "language": "g.addV(\"person\").property(\"name\", \"marko\").addV(\"person\").property(\"name\", \"josh\")",
+                "canonical": "g.addV(\"person\").property(\"name\", \"marko\").addV(\"person\").property(\"name\", \"josh\")",
+                "anonymized": "g.addV(string0).property(string1, string2).addV(string0).property(string1, string3)",
+                "dotnet": "g.AddV((string) \"person\").Property(\"name\", \"marko\").AddV((string) \"person\").Property(\"name\", \"josh\")",
+                "go": "g.AddV(\"person\").Property(\"name\", \"marko\").AddV(\"person\").Property(\"name\", \"josh\")",
+                "groovy": "g.addV(\"person\").property(\"name\", \"marko\").addV(\"person\").property(\"name\", \"josh\")",
+                "java": "g.addV(\"person\").property(\"name\", \"marko\").addV(\"person\").property(\"name\", \"josh\")",
+                "javascript": "g.addV(\"person\").property(\"name\", \"marko\").addV(\"person\").property(\"name\", \"josh\")",
+                "python": "g.add_v('person').property('name', 'marko').add_v('person').property('name', 'josh')"
+            },
+            {
+                "original": "g.addE(\"knows\", \"trusts\").from(__.V().has(\"name\", \"marko\")).to(__.V().has(\"name\", \"josh\")).labels().fold()",
+                "language": "g.addE(\"knows\", \"trusts\").from(__.V().has(\"name\", \"marko\")).to(__.V().has(\"name\", \"josh\")).labels().fold()",
+                "canonical": "g.addE(\"knows\", \"trusts\").from(__.V().has(\"name\", \"marko\")).to(__.V().has(\"name\", \"josh\")).labels().fold()",
+                "anonymized": "g.addE(string0, string1).from(__.V().has(string2, string3)).to(__.V().has(string2, string4)).labels().fold()",
+                "dotnet": "g.AddE((string) \"knows\", (string) \"trusts\").From(__.V().Has(\"name\", \"marko\")).To(__.V().Has(\"name\", \"josh\")).Labels().Fold()",
+                "go": "g.AddE(\"knows\", \"trusts\").From(gremlingo.T__.V().Has(\"name\", \"marko\")).To(gremlingo.T__.V().Has(\"name\", \"josh\")).Labels().Fold()",
+                "groovy": "g.addE(\"knows\", \"trusts\").from(__.V().has(\"name\", \"marko\")).to(__.V().has(\"name\", \"josh\")).labels().fold()",
+                "java": "g.addE(\"knows\", \"trusts\").from(__.V().has(\"name\", \"marko\")).to(__.V().has(\"name\", \"josh\")).labels().fold()",
+                "javascript": "g.addE(\"knows\", \"trusts\").from_(__.V().has(\"name\", \"marko\")).to(__.V().has(\"name\", \"josh\")).labels().fold()",
+                "python": "g.add_e('knows', 'trusts').from_(__.V().has('name', 'marko')).to(__.V().has('name', 'josh')).labels().fold()"
+            },
+            {
+                "original": "g.E().hasLabel(\"knows\")",
+                "language": "g.E().hasLabel(\"knows\")",
+                "canonical": "g.E().hasLabel(\"knows\")",
+                "anonymized": "g.E().hasLabel(string0)",
+                "dotnet": "g.E().HasLabel(\"knows\")",
+                "go": "g.E().HasLabel(\"knows\")",
+                "groovy": "g.E().hasLabel(\"knows\")",
+                "java": "g.E().hasLabel(\"knows\")",
+                "javascript": "g.E().hasLabel(\"knows\")",
+                "python": "g.E().has_label('knows')"
+            },
+            {
+                "original": "g.E().hasLabel(\"trusts\")",
+                "language": "g.E().hasLabel(\"trusts\")",
+                "canonical": "g.E().hasLabel(\"trusts\")",
+                "anonymized": "g.E().hasLabel(string0)",
+                "dotnet": "g.E().HasLabel(\"trusts\")",
+                "go": "g.E().HasLabel(\"trusts\")",
+                "groovy": "g.E().hasLabel(\"trusts\")",
+                "java": "g.E().hasLabel(\"trusts\")",
+                "javascript": "g.E().hasLabel(\"trusts\")",
+                "python": "g.E().has_label('trusts')"
+            }
+        ]
+    },
+    {
+        "scenario": "g_addEXa_b_cX_from_V_to_V_labels_count",
+        "traversals": [
+            {
+                "original": "g.addV(\"person\").property(\"name\", \"marko\").addV(\"person\").property(\"name\", \"josh\")",
+                "language": "g.addV(\"person\").property(\"name\", \"marko\").addV(\"person\").property(\"name\", \"josh\")",
+                "canonical": "g.addV(\"person\").property(\"name\", \"marko\").addV(\"person\").property(\"name\", \"josh\")",
+                "anonymized": "g.addV(string0).property(string1, string2).addV(string0).property(string1, string3)",
+                "dotnet": "g.AddV((string) \"person\").Property(\"name\", \"marko\").AddV((string) \"person\").Property(\"name\", \"josh\")",
+                "go": "g.AddV(\"person\").Property(\"name\", \"marko\").AddV(\"person\").Property(\"name\", \"josh\")",
+                "groovy": "g.addV(\"person\").property(\"name\", \"marko\").addV(\"person\").property(\"name\", \"josh\")",
+                "java": "g.addV(\"person\").property(\"name\", \"marko\").addV(\"person\").property(\"name\", \"josh\")",
+                "javascript": "g.addV(\"person\").property(\"name\", \"marko\").addV(\"person\").property(\"name\", \"josh\")",
+                "python": "g.add_v('person').property('name', 'marko').add_v('person').property('name', 'josh')"
+            },
+            {
+                "original": "g.addE(\"a\", \"b\", \"c\").from(__.V().has(\"name\", \"marko\")).to(__.V().has(\"name\", \"josh\")).labels().count()",
+                "language": "g.addE(\"a\", \"b\", \"c\").from(__.V().has(\"name\", \"marko\")).to(__.V().has(\"name\", \"josh\")).labels().count()",
+                "canonical": "g.addE(\"a\", \"b\", \"c\").from(__.V().has(\"name\", \"marko\")).to(__.V().has(\"name\", \"josh\")).labels().count()",
+                "anonymized": "g.addE(string0, string1, string2).from(__.V().has(string3, string4)).to(__.V().has(string3, string5)).labels().count()",
+                "dotnet": "g.AddE((string) \"a\", (string) \"b\", (string) \"c\").From(__.V().Has(\"name\", \"marko\")).To(__.V().Has(\"name\", \"josh\")).Labels().Count()",
+                "go": "g.AddE(\"a\", \"b\", \"c\").From(gremlingo.T__.V().Has(\"name\", \"marko\")).To(gremlingo.T__.V().Has(\"name\", \"josh\")).Labels().Count()",
+                "groovy": "g.addE(\"a\", \"b\", \"c\").from(__.V().has(\"name\", \"marko\")).to(__.V().has(\"name\", \"josh\")).labels().count()",
+                "java": "g.addE(\"a\", \"b\", \"c\").from(__.V().has(\"name\", \"marko\")).to(__.V().has(\"name\", \"josh\")).labels().count()",
+                "javascript": "g.addE(\"a\", \"b\", \"c\").from_(__.V().has(\"name\", \"marko\")).to(__.V().has(\"name\", \"josh\")).labels().count()",
+                "python": "g.add_e('a', 'b', 'c').from_(__.V().has('name', 'marko')).to(__.V().has('name', 'josh')).labels().count()"
+            }
+        ]
+    },
     {
         "scenario": "g_VX1X_addVXanimalX_propertyXage_selectXaX_byXageXX_propertyXname_puppyX",
         "traversals": [
@@ -41544,6 +41626,59 @@
             }
         ]
     },
+    {
+        "scenario": "g_E_addLabelXfriendX_labels_fold",
+        "traversals": [
+            {
+                "original": "g.addV(\"person\").property(\"name\", \"marko\").as(\"a\").addV(\"person\").property(\"name\", \"josh\").as(\"b\").addE(\"knows\").from(\"a\").to(\"b\")",
+                "language": "g.addV(\"person\").property(\"name\", \"marko\").as(\"a\").addV(\"person\").property(\"name\", \"josh\").as(\"b\").addE(\"knows\").from(\"a\").to(\"b\")",
+                "canonical": "g.addV(\"person\").property(\"name\", \"marko\").as(\"a\").addV(\"person\").property(\"name\", \"josh\").as(\"b\").addE(\"knows\").from(\"a\").to(\"b\")",
+                "anonymized": "g.addV(string0).property(string1, string2).as(string3).addV(string0).property(string1, string4).as(string5).addE(string6).from(string3).to(string5)",
+                "dotnet": "g.AddV((string) \"person\").Property(\"name\", \"marko\").As(\"a\").AddV((string) \"person\").Property(\"name\", \"josh\").As(\"b\").AddE((string) \"knows\").From(\"a\").To(\"b\")",
+                "go": "g.AddV(\"person\").Property(\"name\", \"marko\").As(\"a\").AddV(\"person\").Property(\"name\", \"josh\").As(\"b\").AddE(\"knows\").From(\"a\").To(\"b\")",
+                "groovy": "g.addV(\"person\").property(\"name\", \"marko\").as(\"a\").addV(\"person\").property(\"name\", \"josh\").as(\"b\").addE(\"knows\").from(\"a\").to(\"b\")",
+                "java": "g.addV(\"person\").property(\"name\", \"marko\").as(\"a\").addV(\"person\").property(\"name\", \"josh\").as(\"b\").addE(\"knows\").from(\"a\").to(\"b\")",
+                "javascript": "g.addV(\"person\").property(\"name\", \"marko\").as(\"a\").addV(\"person\").property(\"name\", \"josh\").as(\"b\").addE(\"knows\").from_(\"a\").to(\"b\")",
+                "python": "g.add_v('person').property('name', 'marko').as_('a').add_v('person').property('name', 'josh').as_('b').add_e('knows').from_('a').to('b')"
+            },
+            {
+                "original": "g.E().addLabel(\"friend\").labels().fold()",
+                "language": "g.E().addLabel(\"friend\").labels().fold()",
+                "canonical": "g.E().addLabel(\"friend\").labels().fold()",
+                "anonymized": "g.E().addLabel(string0).labels().fold()",
+                "dotnet": "g.E().AddLabel(\"friend\").Labels().Fold()",
+                "go": "g.E().AddLabel(\"friend\").Labels().Fold()",
+                "groovy": "g.E().addLabel(\"friend\").labels().fold()",
+                "java": "g.E().addLabel(\"friend\").labels().fold()",
+                "javascript": "g.E().addLabel(\"friend\").labels().fold()",
+                "python": "g.E().add_label('friend').labels().fold()"
+            },
+            {
+                "original": "g.E().hasLabel(\"knows\")",
+                "language": "g.E().hasLabel(\"knows\")",
+                "canonical": "g.E().hasLabel(\"knows\")",
+                "anonymized": "g.E().hasLabel(string0)",
+                "dotnet": "g.E().HasLabel(\"knows\")",
+                "go": "g.E().HasLabel(\"knows\")",
+                "groovy": "g.E().hasLabel(\"knows\")",
+                "java": "g.E().hasLabel(\"knows\")",
+                "javascript": "g.E().hasLabel(\"knows\")",
+                "python": "g.E().has_label('knows')"
+            },
+            {
+                "original": "g.E().hasLabel(\"friend\")",
+                "language": "g.E().hasLabel(\"friend\")",
+                "canonical": "g.E().hasLabel(\"friend\")",
+                "anonymized": "g.E().hasLabel(string0)",
+                "dotnet": "g.E().HasLabel(\"friend\")",
+                "go": "g.E().HasLabel(\"friend\")",
+                "groovy": "g.E().hasLabel(\"friend\")",
+                "java": "g.E().hasLabel(\"friend\")",
+                "javascript": "g.E().hasLabel(\"friend\")",
+                "python": "g.E().has_label('friend')"
+            }
+        ]
+    },
     {
         "scenario": "g_V_valueXnameX_aggregateXxX_capXxX",
         "traversals": [
@@ -42653,6 +42788,88 @@
             }
         ]
     },
+    {
+        "scenario": "g_E_dropLabelXknowsX_labels",
+        "traversals": [
+            {
+                "original": "g.addV(\"person\").as(\"a\").addV(\"person\").as(\"b\").addE(\"knows\", \"trusts\").from(\"a\").to(\"b\")",
+                "language": "g.addV(\"person\").as(\"a\").addV(\"person\").as(\"b\").addE(\"knows\", \"trusts\").from(\"a\").to(\"b\")",
+                "canonical": "g.addV(\"person\").as(\"a\").addV(\"person\").as(\"b\").addE(\"knows\", \"trusts\").from(\"a\").to(\"b\")",
+                "anonymized": "g.addV(string0).as(string1).addV(string0).as(string2).addE(string3, string4).from(string1).to(string2)",
+                "dotnet": "g.AddV((string) \"person\").As(\"a\").AddV((string) \"person\").As(\"b\").AddE(\"knows\", \"trusts\").From(\"a\").To(\"b\")",
+                "go": "g.AddV(\"person\").As(\"a\").AddV(\"person\").As(\"b\").AddE(\"knows\", \"trusts\").From(\"a\").To(\"b\")",
+                "groovy": "g.addV(\"person\").as(\"a\").addV(\"person\").as(\"b\").addE(\"knows\", \"trusts\").from(\"a\").to(\"b\")",
+                "java": "g.addV(\"person\").as(\"a\").addV(\"person\").as(\"b\").addE(\"knows\", \"trusts\").from(\"a\").to(\"b\")",
+                "javascript": "g.addV(\"person\").as(\"a\").addV(\"person\").as(\"b\").addE(\"knows\", \"trusts\").from_(\"a\").to(\"b\")",
+                "python": "g.add_v('person').as_('a').add_v('person').as_('b').add_e('knows', 'trusts').from_('a').to('b')"
+            },
+            {
+                "original": "g.E().dropLabel(\"knows\").labels().fold()",
+                "language": "g.E().dropLabel(\"knows\").labels().fold()",
+                "canonical": "g.E().dropLabel(\"knows\").labels().fold()",
+                "anonymized": "g.E().dropLabel(string0).labels().fold()",
+                "dotnet": "g.E().DropLabel(\"knows\").Labels().Fold()",
+                "go": "g.E().DropLabel(\"knows\").Labels().Fold()",
+                "groovy": "g.E().dropLabel(\"knows\").labels().fold()",
+                "java": "g.E().dropLabel(\"knows\").labels().fold()",
+                "javascript": "g.E().dropLabel(\"knows\").labels().fold()",
+                "python": "g.E().drop_label('knows').labels().fold()"
+            },
+            {
+                "original": "g.E().hasLabel(\"knows\")",
+                "language": "g.E().hasLabel(\"knows\")",
+                "canonical": "g.E().hasLabel(\"knows\")",
+                "anonymized": "g.E().hasLabel(string0)",
+                "dotnet": "g.E().HasLabel(\"knows\")",
+                "go": "g.E().HasLabel(\"knows\")",
+                "groovy": "g.E().hasLabel(\"knows\")",
+                "java": "g.E().hasLabel(\"knows\")",
+                "javascript": "g.E().hasLabel(\"knows\")",
+                "python": "g.E().has_label('knows')"
+            },
+            {
+                "original": "g.E().hasLabel(\"trusts\")",
+                "language": "g.E().hasLabel(\"trusts\")",
+                "canonical": "g.E().hasLabel(\"trusts\")",
+                "anonymized": "g.E().hasLabel(string0)",
+                "dotnet": "g.E().HasLabel(\"trusts\")",
+                "go": "g.E().HasLabel(\"trusts\")",
+                "groovy": "g.E().hasLabel(\"trusts\")",
+                "java": "g.E().hasLabel(\"trusts\")",
+                "javascript": "g.E().hasLabel(\"trusts\")",
+                "python": "g.E().has_label('trusts')"
+            }
+        ]
+    },
+    {
+        "scenario": "g_E_dropLabels_labels",
+        "traversals": [
+            {
+                "original": "g.addV(\"person\").as(\"a\").addV(\"person\").as(\"b\").addE(\"knows\", \"trusts\").from(\"a\").to(\"b\")",
+                "language": "g.addV(\"person\").as(\"a\").addV(\"person\").as(\"b\").addE(\"knows\", \"trusts\").from(\"a\").to(\"b\")",
+                "canonical": "g.addV(\"person\").as(\"a\").addV(\"person\").as(\"b\").addE(\"knows\", \"trusts\").from(\"a\").to(\"b\")",
+                "anonymized": "g.addV(string0).as(string1).addV(string0).as(string2).addE(string3, string4).from(string1).to(string2)",
+                "dotnet": "g.AddV((string) \"person\").As(\"a\").AddV((string) \"person\").As(\"b\").AddE(\"knows\", \"trusts\").From(\"a\").To(\"b\")",
+                "go": "g.AddV(\"person\").As(\"a\").AddV(\"person\").As(\"b\").AddE(\"knows\", \"trusts\").From(\"a\").To(\"b\")",
+                "groovy": "g.addV(\"person\").as(\"a\").addV(\"person\").as(\"b\").addE(\"knows\", \"trusts\").from(\"a\").to(\"b\")",
+                "java": "g.addV(\"person\").as(\"a\").addV(\"person\").as(\"b\").addE(\"knows\", \"trusts\").from(\"a\").to(\"b\")",
+                "javascript": "g.addV(\"person\").as(\"a\").addV(\"person\").as(\"b\").addE(\"knows\", \"trusts\").from_(\"a\").to(\"b\")",
+                "python": "g.add_v('person').as_('a').add_v('person').as_('b').add_e('knows', 'trusts').from_('a').to('b')"
+            },
+            {
+                "original": "g.E().dropLabels().labels()",
+                "language": "g.E().dropLabels().labels()",
+                "canonical": "g.E().dropLabels().labels()",
+                "anonymized": "g.E().dropLabels().labels()",
+                "dotnet": "g.E().DropLabels().Labels()",
+                "go": "g.E().DropLabels().Labels()",
+                "groovy": "g.E().dropLabels().labels()",
+                "java": "g.E().dropLabels().labels()",
+                "javascript": "g.E().dropLabels().labels()",
+                "python": "g.E().drop_labels().labels()"
+            }
+        ]
+    },
     {
         "scenario": "g_V_fail",
         "traversals": [
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/AddEdge.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/AddEdge.feature
index 02c2be3d7b..267cefaec9 100644
--- a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/AddEdge.feature
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/AddEdge.feature
@@ -528,4 +528,36 @@ Feature: Step - addE()
         addE("knows").from(__.V().has("name","marko"))
       """
     When iterated to list
-    Then the traversal will raise an error with message containing text of "must resolve to a Vertex or the ID of a Vertex present in the graph"
\ No newline at end of file
+    Then the traversal will raise an error with message containing text of "must resolve to a Vertex or the ID of a Vertex present in the graph"
+
+  @MultiLabel
+  Scenario: g_addEXa_bX_from_V_to_V_labels_fold
+    Given the empty graph
+    And the graph initializer of
+      """
+      g.addV("person").property("name", "marko").addV("person").property("name", "josh")
+      """
+    And the traversal of
+      """
+      g.addE("knows", "trusts").from(__.V().has("name", "marko")).to(__.V().has("name", "josh")).labels().fold()
+      """
+    When iterated to list
+    Then the result should have a count of 1
+    And the graph should return 1 for count of "g.E().hasLabel(\"knows\")"
+    And the graph should return 1 for count of "g.E().hasLabel(\"trusts\")"
+
+  @MultiLabel
+  Scenario: g_addEXa_b_cX_from_V_to_V_labels_count
+    Given the empty graph
+    And the graph initializer of
+      """
+      g.addV("person").property("name", "marko").addV("person").property("name", "josh")
+      """
+    And the traversal of
+      """
+      g.addE("a", "b", "c").from(__.V().has("name", "marko")).to(__.V().has("name", "josh")).labels().count()
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | d[3].l |
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/MergeEdge.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/MergeEdge.feature
index 6ffb7da16d..0513f5451d 100644
--- a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/MergeEdge.feature
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/MergeEdge.feature
@@ -1108,4 +1108,6 @@ Feature: Step - mergeE()
     Then the result should have a count of 1
     And the graph should return 2 for count of "g.V()"
     And the graph should return 1 for count of "g.E().hasLabel(\"knows\")"
-    And the graph should return 0 for count of "g.E().hasLabel(\"knows\").has(\"weight\")"
\ No newline at end of file
+    And the graph should return 0 for count of "g.E().hasLabel(\"knows\").has(\"weight\")"
+
+
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/AddLabel.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/AddLabel.feature
index 821b80ab72..5c0891ebb8 100644
--- a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/AddLabel.feature
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/AddLabel.feature
@@ -64,3 +64,19 @@ Feature: Step - addLabel()
     Then the result should be unordered
       | result |
       | d[1].l |
+
+  @MultiLabel
+  Scenario: g_E_addLabelXfriendX_labels_fold
+    Given the empty graph
+    And the graph initializer of
+      """
+      g.addV("person").property("name", "marko").as("a").addV("person").property("name", "josh").as("b").addE("knows").from("a").to("b")
+      """
+    And the traversal of
+      """
+      g.E().addLabel("friend").labels().fold()
+      """
+    When iterated to list
+    Then the result should have a count of 1
+    And the graph should return 1 for count of "g.E().hasLabel(\"knows\")"
+    And the graph should return 1 for count of "g.E().hasLabel(\"friend\")"
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/DropLabel.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/DropLabel.feature
index 051cc793af..0c60f6c3c0 100644
--- a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/DropLabel.feature
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/DropLabel.feature
@@ -81,3 +81,35 @@ Feature: Step - dropLabel() / dropLabels()
     Then the result should be unordered
       | result |
       | vertex |
+
+  @MultiLabel
+  Scenario: g_E_dropLabelXknowsX_labels
+    Given the empty graph
+    And the graph initializer of
+      """
+      g.addV("person").as("a").addV("person").as("b").addE("knows", "trusts").from("a").to("b")
+      """
+    And the traversal of
+      """
+      g.E().dropLabel("knows").labels().fold()
+      """
+    When iterated to list
+    Then the result should have a count of 1
+    And the graph should return 0 for count of "g.E().hasLabel(\"knows\")"
+    And the graph should return 1 for count of "g.E().hasLabel(\"trusts\")"
+
+  @MultiLabel
+  Scenario: g_E_dropLabels_labels
+    Given the empty graph
+    And the graph initializer of
+      """
+      g.addV("person").as("a").addV("person").as("b").addE("knows", "trusts").from("a").to("b")
+      """
+    And the traversal of
+      """
+      g.E().dropLabels().labels()
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | edge   |
diff --git a/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/binary/TypeSerializerFailureTests.java b/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/binary/TypeSerializerFailureTests.java
index 27529203ca..c23ccee3e0 100644
--- a/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/binary/TypeSerializerFailureTests.java
+++ b/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/binary/TypeSerializerFailureTests.java
@@ -72,7 +72,7 @@ public class TypeSerializerFailureTests {
                 vertex,
                 bulkSet,
                 Collections.singletonList(vertex),
-                new ReferenceEdge("an edge", null, vertex, vertex),
+                new ReferenceEdge("an edge", (String) null, vertex, vertex),
                 Lambda.supplier(null),
                 metrics,
                 new DefaultTraversalMetrics(1L, Collections.singletonList(metrics)),


(tinkerpop) 02/06: add a set of simple feature tests

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

xiazcy pushed a commit to branch multi-label-experiment
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git

commit d7b15faeed70aa04200a1554633cdb566a27f565
Author: Yang Xia <xi...@gmail.com>
AuthorDate: Thu Jun 4 22:06:26 2026 -0700

    add a set of simple feature tests
---
 .../Gherkin/GherkinTestRunner.cs                   |   6 ++
 .../Gherkin/IgnoreException.cs                     |   7 +-
 gremlin-go/driver/cucumber/cucumberSteps_test.go   |   1 +
 .../gremlin-javascript/test/cucumber/world.js      |   4 +
 .../src/main/python/tests/feature/feature_steps.py |   4 +
 .../gremlin/test/features/map/AddVertex.feature    |  25 ++++-
 .../gremlin/test/features/map/Labels.feature       | 110 +++++++++++++++++++++
 .../test/features/sideEffect/AddLabel.feature      |  66 +++++++++++++
 .../test/features/sideEffect/DropLabel.feature     |  83 ++++++++++++++++
 .../gremlin/structure/ExceptionCoverageTest.java   |   3 +
 10 files changed, 307 insertions(+), 2 deletions(-)

diff --git a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/GherkinTestRunner.cs b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/GherkinTestRunner.cs
index 6aee902762..04969b5fae 100644
--- a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/GherkinTestRunner.cs
+++ b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/GherkinTestRunner.cs
@@ -125,6 +125,12 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
                         continue;
                     }
 
+                    if (scenario.Tags.Any(t => t.Name == "@MultiLabel"))
+                    {
+                        failedSteps.Add(scenario.Steps.First(), new IgnoreException(IgnoreReason.MultiLabelStepsNotSupported));
+                        continue;
+                    }
+
                     StepBlock? currentStep = null;
                     StepDefinition? stepDefinition = null;
                     foreach (var step in scenario.Steps)
diff --git a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/IgnoreException.cs b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/IgnoreException.cs
index 7001391004..bf3918f253 100644
--- a/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/IgnoreException.cs
+++ b/gremlin-dotnet/test/Gremlin.Net.IntegrationTest/Gherkin/IgnoreException.cs
@@ -70,6 +70,11 @@ namespace Gremlin.Net.IntegrationTest.Gherkin
         /// <summary>
         /// write() is not supported yet for testing
         /// </summary>
-        WriteStepTestingNotSupported
+        WriteStepTestingNotSupported,
+
+        /// <summary>
+        /// Multi-label steps (labels(), addLabel(), dropLabel(), dropLabels()) are not yet available in the .NET GLV
+        /// </summary>
+        MultiLabelStepsNotSupported
     }
 }
\ No newline at end of file
diff --git a/gremlin-go/driver/cucumber/cucumberSteps_test.go b/gremlin-go/driver/cucumber/cucumberSteps_test.go
index 495d56fd40..b4e44f6415 100644
--- a/gremlin-go/driver/cucumber/cucumberSteps_test.go
+++ b/gremlin-go/driver/cucumber/cucumberSteps_test.go
@@ -1133,6 +1133,7 @@ func TestCucumberFeatures(t *testing.T) {
 		ScenarioInitializer:  InitializeScenario,
 		Options: &godog.Options{
 			Tags:     "~@GraphComputerOnly && ~@AllowNullPropertyValues && ~@StepTree && ~@StepWrite && ~@DataChar",
+			Tags:     "~@GraphComputerOnly && ~@AllowNullPropertyValues && ~@StepTree && ~@StepWrite && ~@DataChar && ~@MultiLabel",
 			Format:   "pretty",
 			Paths:    []string{getEnvOrDefaultString("CUCUMBER_FEATURE_FOLDER", "../../../gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features")},
 			TestingT: t, // Testing instance that will run subtests.
diff --git a/gremlin-js/gremlin-javascript/test/cucumber/world.js b/gremlin-js/gremlin-javascript/test/cucumber/world.js
index 563abb8ce8..8dcd7d18ba 100644
--- a/gremlin-js/gremlin-javascript/test/cucumber/world.js
+++ b/gremlin-js/gremlin-javascript/test/cucumber/world.js
@@ -118,6 +118,10 @@ Before({tags: "@DataDuration"}, function() {
   return 'skipped'
 })
 
+Before({tags: "@MultiLabel"}, function() {
+  return 'skipped'
+})
+
 function getVertices(connection) {
   const g = anon.traversal().withRemote(connection);
   return g.V().group().by('name').by(__.tail()).next().then(it => {
diff --git a/gremlin-python/src/main/python/tests/feature/feature_steps.py b/gremlin-python/src/main/python/tests/feature/feature_steps.py
index f40c3fa91e..56feab3a29 100644
--- a/gremlin-python/src/main/python/tests/feature/feature_steps.py
+++ b/gremlin-python/src/main/python/tests/feature/feature_steps.py
@@ -90,6 +90,10 @@ def choose_graph(step, graph_name):
     if not step.context.ignore:
         step.context.ignore = "WithReservedKeysVerificationStrategy" in tagset
 
+    # Multi-label steps not yet available in Python GLV
+    if not step.context.ignore:
+        step.context.ignore = "MultiLabel" in tagset
+
     if (step.context.ignore):
         return
 
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/AddVertex.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/AddVertex.feature
index 99e1492f56..0d7fdaf2c7 100644
--- a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/AddVertex.feature
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/AddVertex.feature
@@ -703,4 +703,27 @@ Feature: Step - addV()
     When iterated to list
     Then the result should be unordered
       | result |
-      | d[2010].i |
\ No newline at end of file
+      | d[2010].i |
+
+  @MultiLabel
+  Scenario: g_addVXa_bX_labels
+    Given the empty graph
+    And the traversal of
+      """
+      g.addV("a", "b").labels().fold()
+      """
+    When iterated to list
+    Then the result should have a count of 1
+    And the graph should return 1 for count of "g.V().hasLabel(\"a\").hasLabel(\"b\")"
+
+  @MultiLabel
+  Scenario: g_addVXa_b_cX_labels_count
+    Given the empty graph
+    And the traversal of
+      """
+      g.addV("a", "b", "c").labels().count()
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | d[3].l |
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/Labels.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/Labels.feature
new file mode 100644
index 0000000000..322d0ca42c
--- /dev/null
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/map/Labels.feature
@@ -0,0 +1,110 @@
+# 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.
+
+@StepClassMap @StepLabels @MultiLabel
+Feature: Step - labels()
+
+  @MultiLabel
+  Scenario: g_V_hasLabelXpersonX_labels
+    Given the modern graph
+    And the traversal of
+      """
+      g.V().hasLabel("person").labels()
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | person |
+      | person |
+      | person |
+      | person |
+
+  @MultiLabel
+  Scenario: g_addVXa_bX_labels
+    Given the empty graph
+    And the graph initializer of
+      """
+      g.addV("a", "b")
+      """
+    And the traversal of
+      """
+      g.V().labels()
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | a |
+      | b |
+
+  @MultiLabel
+  Scenario: g_addVXa_bX_labels_fold
+    Given the empty graph
+    And the graph initializer of
+      """
+      g.addV("a", "b")
+      """
+    And the traversal of
+      """
+      g.V().labels().fold()
+      """
+    When iterated to list
+    Then the result should have a count of 1
+
+  @MultiLabel
+  Scenario: g_addVXa_bX_labels_count
+    Given the empty graph
+    And the graph initializer of
+      """
+      g.addV("a", "b")
+      """
+    And the traversal of
+      """
+      g.V().labels().count()
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | d[2].l |
+
+  @MultiLabel
+  Scenario: g_addV_labels
+    Given the empty graph
+    And the graph initializer of
+      """
+      g.addV()
+      """
+    And the traversal of
+      """
+      g.V().labels()
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | vertex |
+
+  @MultiLabel
+  Scenario: g_E_labels
+    Given the modern graph
+    And the traversal of
+      """
+      g.E().hasLabel("knows").labels()
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | knows |
+      | knows |
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/AddLabel.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/AddLabel.feature
new file mode 100644
index 0000000000..821b80ab72
--- /dev/null
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/AddLabel.feature
@@ -0,0 +1,66 @@
+# 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.
+
+@StepClassSideEffect @StepAddLabel @MultiLabel
+Feature: Step - addLabel()
+
+  @MultiLabel
+  Scenario: g_V_hasLabelXpersonX_hasXname_markoX_addLabelXemployeeX_labels
+    Given the empty graph
+    And the graph initializer of
+      """
+      g.addV("person").property("name", "marko")
+      """
+    And the traversal of
+      """
+      g.V().hasLabel("person").has("name", "marko").addLabel("employee").labels().fold()
+      """
+    When iterated to list
+    Then the result should have a count of 1
+    And the graph should return 1 for count of "g.V().hasLabel(\"person\").hasLabel(\"employee\")"
+
+  @MultiLabel
+  Scenario: g_V_addLabelXa_bX_labels_count
+    Given the empty graph
+    And the graph initializer of
+      """
+      g.addV("person")
+      """
+    And the traversal of
+      """
+      g.V().addLabel("a", "b").labels().count()
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | d[3].l |
+
+  @MultiLabel
+  Scenario: g_V_addLabelXexistingX_labels_count
+    Given the empty graph
+    And the graph initializer of
+      """
+      g.addV("person")
+      """
+    And the traversal of
+      """
+      g.V().addLabel("person").labels().count()
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | d[1].l |
diff --git a/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/DropLabel.feature b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/DropLabel.feature
new file mode 100644
index 0000000000..051cc793af
--- /dev/null
+++ b/gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features/sideEffect/DropLabel.feature
@@ -0,0 +1,83 @@
+# 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.
+
+@StepClassSideEffect @StepDropLabel @MultiLabel
+Feature: Step - dropLabel() / dropLabels()
+
+  @MultiLabel
+  Scenario: g_V_dropLabelXaX_labels
+    Given the empty graph
+    And the graph initializer of
+      """
+      g.addV("a", "b")
+      """
+    And the traversal of
+      """
+      g.V().dropLabel("a").labels().fold()
+      """
+    When iterated to list
+    Then the result should have a count of 1
+    And the graph should return 0 for count of "g.V().hasLabel(\"a\")"
+    And the graph should return 1 for count of "g.V().hasLabel(\"b\")"
+
+  @MultiLabel
+  Scenario: g_V_dropLabels_labels
+    Given the empty graph
+    And the graph initializer of
+      """
+      g.addV("a", "b")
+      """
+    And the traversal of
+      """
+      g.V().dropLabels().labels()
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | vertex |
+
+  @MultiLabel
+  Scenario: g_V_dropLabelXa_bX_labels
+    Given the empty graph
+    And the graph initializer of
+      """
+      g.addV("a", "b", "c")
+      """
+    And the traversal of
+      """
+      g.V().dropLabel("a", "b").labels()
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | c |
+
+  @MultiLabel
+  Scenario: g_V_dropLabels_defaultLabel
+    Given the empty graph
+    And the graph initializer of
+      """
+      g.addV("person")
+      """
+    And the traversal of
+      """
+      g.V().dropLabels().labels()
+      """
+    When iterated to list
+    Then the result should be unordered
+      | result |
+      | vertex |
diff --git a/gremlin-test/src/test/java/org/apache/tinkerpop/gremlin/structure/ExceptionCoverageTest.java b/gremlin-test/src/test/java/org/apache/tinkerpop/gremlin/structure/ExceptionCoverageTest.java
index a8f3946128..17b8b020dc 100644
--- a/gremlin-test/src/test/java/org/apache/tinkerpop/gremlin/structure/ExceptionCoverageTest.java
+++ b/gremlin-test/src/test/java/org/apache/tinkerpop/gremlin/structure/ExceptionCoverageTest.java
@@ -75,6 +75,9 @@ public class ExceptionCoverageTest {
             add("org.apache.tinkerpop.gremlin.structure.Element$Exceptions#elementAlreadyRemoved"); // as of 3.1.0
             add("org.apache.tinkerpop.gremlin.structure.Graph$Exceptions#traversalEngineNotSupported"); // as of 3.2.0
 
+            // this is a general default exception for providers that don't support label mutation:
+            add("org.apache.tinkerpop.gremlin.structure.Element$Exceptions#labelMutationNotSupported");
+
             // need to write consistency tests for the following items still...........
             add("org.apache.tinkerpop.gremlin.process.computer.GraphComputer$Exceptions#supportsDirectObjects");
         }};