diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..4c4aa1a
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,8 @@
+
+# dot files
+.vscode
+.DS_Store
+
+# bazel
+bazel-*
+
diff --git a/BUILD b/BUILD
new file mode 100644
index 0000000..04e4d6e
--- /dev/null
+++ b/BUILD
@@ -0,0 +1,44 @@
+# Bazel Build File For Type system
+
+
+cc_library(
+    name="graph",
+    visibility = ["//visibility:public"],
+    hdrs=glob([
+        "src/**/*.h*",
+    ]),
+    srcs=glob([
+        "src/**/*.c*"
+    ]),
+    includes=[
+        "src"
+    ],
+    copts = select({
+        "@bazel_tools//src/conditions:windows": ["/std:c++17"],
+        "@bazel_tools//src/conditions:darwin": ["-std=c++17"],
+        "//conditions:default": ["-std=c++17"],
+    }),
+    deps=[
+        "@stdext//:stdext",
+        "@spdlog//:headers",
+    ]
+)
+
+
+
+cc_test(
+    name = "test",
+    srcs = glob([
+        "test/**/*.h*", 
+        "test/**/*.cpp"
+    ]),
+    copts = select({
+        "@bazel_tools//src/conditions:windows": ["/std:c++17"],
+        "@bazel_tools//src/conditions:darwin": ["-std=c++17"],
+        "//conditions:default": ["-std=c++17"],
+    }),
+    deps = [
+        ":graph",
+        "@catch//:single_include",
+    ],
+)
\ No newline at end of file
diff --git a/WORKSPACE b/WORKSPACE
new file mode 100644
index 0000000..e64bb0a
--- /dev/null
+++ b/WORKSPACE
@@ -0,0 +1,36 @@
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+
+http_archive(
+    name = "catch",
+    url = "https://github.com/cgrinker/Catch2/archive/5e6488fd9949cb41d717a72c8c4603b7e37d68cd.zip",
+    sha256 = "91e3e0610572adefa301a6e55ac48ab0a3c8ff61787ce6930e346ff36e86905c",
+    strip_prefix = "Catch2-5e6488fd9949cb41d717a72c8c4603b7e37d68cd",
+)
+
+########################
+# spdlog:
+
+http_archive(
+    name = "spdlog",
+    urls = ["https://github.com/cgrinker/spdlog/archive/3bf4a07dc286e10fa32d6503fded647c9ee02d26.zip"],
+    strip_prefix = "spdlog-3bf4a07dc286e10fa32d6503fded647c9ee02d26",
+    sha256 = "d00ccd202e2abae832441b9121330a4b8b82fdc60564edb315c89506fa3772c3",
+)
+
+########################
+# stdext
+http_archive(
+    name = "stdext",
+    urls = ["https://github.com/cultlang/stdext/archive/v1.0.0.zip"],
+    strip_prefix = "stdext-1.0.0",
+    sha256 = "2c008ad1de4e520c2b7ef24ea6d20e677afd1cf411274cb89da7aa08e853b3f1",
+)
+
+########################
+# Fmt
+http_archive(
+    name = "fmt",
+    urls = ["https://github.com/cgrinker/fmt/archive/f16f77297e6bb4df38d4c858edb3295f55716cb4.zip"],
+    strip_prefix = "fmt-f16f77297e6bb4df38d4c858edb3295f55716cb4",
+    sha256 = "edcacda20bf46be208fbc49cedee2a8a321005dd833752ccc6aa7a1a9d75dc23",
+)
diff --git a/src/graph/algo.hpp b/src/graph/algo.hpp
new file mode 100644
index 0000000..3e3f199
--- /dev/null
+++ b/src/graph/algo.hpp
@@ -0,0 +1,79 @@
+#pragma once
+
+#include <map>
+#include <vector>
+
+#include "util.hpp"
+
+/*
+ * This file contains the various minor algorithms and is laid out as follows:
+ * 
+ * - edgeIsIncoming
+ * - findNode
+ * - collectEdges
+ * - collectNodes
+ * - copyGraph (TODO)
+ */
+
+namespace graph
+{
+    template<typename TGraph>
+    bool edgeIsIncoming(typename TGraph::Node const* n, typename TGraph::Edge const* e)
+    {
+        return (e->nodes[0] != n) != TGraph::isEdgeInverted(e);
+    }
+    template<typename TGraph>
+    bool edgeIsOutgoing(typename TGraph::Node const* n, typename TGraph::Edge const* e)
+    {
+        return (e->nodes[0] == n) != TGraph::isEdgeInverted(e);
+    }
+
+    template<typename TGraph>
+    typename TGraph::Node const* findNode(TGraph const& g, typename TGraph::CoreData const& v)
+    {
+        typename TGraph::Node const* res = nullptr;
+        g.forAllNodes([&](auto n)
+        {
+            if (n->data == v)
+                res = n;
+            return n->data != v;
+        });
+        return res;
+    }
+
+    template<typename TGraph, typename Func>
+    typename std::vector<typename TGraph::Edge const*> collectEdges(TGraph const& g, typename TGraph::Node const* n, Func const& func)
+    {
+        typename std::vector<typename TGraph::Edge const*> res;
+        g.forAllEdgesOnNode(n, [&](auto e)
+        {
+            if (func(e))
+                res.push_back(e);
+        });
+        return res;
+    }
+
+    template<typename TGraph, typename Func>
+    typename std::vector<typename TGraph::Node const*> collectNodes(TGraph const& g, typename TGraph::Edge const* e, Func const& func)
+    {
+        typename std::vector<typename TGraph::Node const*> res;
+        g.forAllNodesInEdge(e, [&](auto n)
+        {
+            if (func(n))
+                res.push_back(n);
+        });
+        return res;
+    }
+
+    template<typename TGraph>
+    void copyGraph(TGraph& dst, TGraph const& src)
+    {
+        // TODO: need a copy data-section function to copy types and other data
+        //std::map<TGraph::Label*, TGraph::Label*> _labelMap;
+
+        src.forAllLabels([&](auto l)
+        {
+            dst.addLabel(l->data);
+        });
+    }
+}
diff --git a/src/graph/graph.hpp b/src/graph/graph.hpp
new file mode 100644
index 0000000..ac15849
--- /dev/null
+++ b/src/graph/graph.hpp
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <map>
+#include <vector>
+#include <deque>
+
+/*
+    This header only graph library has some very specific design constraints:
+
+    * Highly configurable, it should be usable in a lot of circumstances.
+        * C friendly potential.
+    * Supports node labels, properties, and sorted n-ary edges.
+    * Supports parent graphs, which it can override locally.
+    * This necessitates component style storage.
+    * Supports type based helper lookups.
+*/
+
+#include "util.hpp"
+
+#include "model/core.hpp"
+#include "model/typed.hpp"
+#include "model/todo.hpp"
+#include "model/final.hpp"
+
+#include "algo.hpp"
+
+#include "query/engine.hpp"
+#include "query/query.hpp"
+#include "query/query_library_core.hpp"
+
+namespace graph
+{
+    template<typename TGraph, template <typename, typename> typename TGraphQueryLibrary = GraphQueryLibraryCore>
+    GraphQuery<TGraph, TGraphQueryLibrary> query(TGraph* g)
+    {
+        return GraphQuery<TGraph, TGraphQueryLibrary>(g);
+    }
+}
diff --git a/src/graph/model/core.hpp b/src/graph/model/core.hpp
new file mode 100644
index 0000000..f18d431
--- /dev/null
+++ b/src/graph/model/core.hpp
@@ -0,0 +1,404 @@
+#pragma once
+
+#include <vector>
+#include <deque>
+
+#include "../util.hpp"
+
+namespace graph
+{
+    struct void_t
+    {
+    };
+
+    template<typename TCoreData, typename TBase = void_t>
+    struct basic_core_config : public TBase
+    {
+        using CoreData = TCoreData;
+
+        using LabelData = void_t;
+        using NodeData = void_t;
+        using EdgeData = void_t;
+        using PropData = void_t;
+
+        // support plf colony?
+        template<typename T>
+        using Storage = std::deque<T>;
+    };
+
+    // TODO, another graph type that is more effeciently organized
+    //   maybe by not supporting parent overrides
+    template <typename TConfig>
+    class GraphCore
+    {
+    // This type types:
+    public:
+        // TODO move value kind out of this
+        // TODO a way for this to be used by wrapping templates
+        enum class MetaFlags : uint32_t
+        {
+            None = 0,
+
+            Mask_Kind = (4 - 1) << 1,
+            Value_Kind_Label = ((uint8_t)GraphKind::Label - 1) << 1,
+            Value_Kind_Node = ((uint8_t)GraphKind::Node - 1) << 1,
+            Value_Kind_Edge = ((uint8_t)GraphKind::Edge - 1) << 1,
+            Value_Kind_Prop = ((uint8_t)GraphKind::Prop - 1) << 1,
+
+            Flag_InverseEdge = 1 << 3,
+            //Flag_Override = 1 << 4,
+        };
+
+    // Graph types:
+    public:
+        using Config = TConfig;
+        
+        using CoreData = typename Config::CoreData;
+
+        using LabelData = typename Config::LabelData;
+        using NodeData = typename Config::NodeData;
+        using EdgeData = typename Config::EdgeData;
+        using PropData = typename Config::PropData;
+
+        template<typename T>
+        using Storage = typename Config::template Storage<T>;
+
+        struct Core
+        {
+        public:
+            CoreData data;
+            MetaFlags flags;
+        };
+
+        struct Label;
+        struct Node;
+        struct Edge;
+        struct Prop;
+
+        // A graph "label" metadata
+        struct Label
+        {
+        public:
+            LabelData label_data;
+
+            std::vector<Node*> nodes;
+        };
+
+        // A graph "node" metadata
+        struct Node
+        {
+        public:
+            NodeData node_data;
+
+            std::vector<Label*> labels;
+            std::vector<Edge*> edges;
+            std::vector<Prop*> props;
+        };
+
+        // A graph "edge" metadata
+        struct Edge
+        {
+        public:
+            EdgeData edge_data;
+
+            std::vector<Node*> nodes;
+            std::vector<Prop*> props;
+        };
+
+        // A graph "prop" metadata
+        struct Prop
+        {
+        public:
+            PropData prop_data;
+
+            Core* owner;
+        };
+
+    // Actual type
+    public:
+        template<typename TFinal>
+        class Actual
+        {
+        public:
+            using MetaFlags = typename TFinal::MetaFlags;
+            using CoreData = typename TFinal::CoreData;
+
+            using Label = typename TFinal::Label;
+            using Node = typename TFinal::Node;
+            using Edge = typename TFinal::Edge;
+            using Prop = typename TFinal::Prop;
+
+        protected:
+            using LabelStorage = typename TFinal::template Storage<Label>;
+            using NodeStorage = typename TFinal::template Storage<Node>;
+            using EdgeStorage = typename TFinal::template Storage<Edge>;
+            using PropStorage = typename TFinal::template Storage<Prop>;
+
+            LabelStorage _labels;
+            NodeStorage _nodes;
+            EdgeStorage _edges;
+            PropStorage _props;
+
+        // Add functions
+        public:
+            inline Label* addLabel(CoreData const& data)
+            {
+                Label& ref = _labels.emplace_back();
+                ref.data = data;
+                ref.flags = MetaFlags::Value_Kind_Label;
+
+                return &ref;
+            }
+
+            inline Node* addNode(CoreData const& data)
+            {
+                Node& ref = _nodes.emplace_back();
+                ref.data = data;
+                ref.flags = MetaFlags::Value_Kind_Node;
+
+                return &ref;
+            }
+            
+            // By default edges point from 0-index to all others
+            inline Edge* addEdge(CoreData const& data, std::vector<Node*> const& nodes, bool invert = false)
+            {
+                auto nodes_size = nodes.size();
+                if (nodes_size < 2)
+                    throw graph_error("Edges must connect at least two nodes.");
+
+                Edge& ref = _edges.emplace_back();
+                ref.data = data;
+                ref.flags = MetaFlags::Value_Kind_Edge;
+                if (invert) ref.flags = (MetaFlags)((uint64_t)ref.flags | (uint64_t)MetaFlags::Flag_InverseEdge);
+
+                ref.nodes.reserve(nodes_size);
+                for (auto node : nodes)
+                {
+                    ref.nodes.push_back(node);
+                    node->edges.push_back(&ref);
+                }
+
+                return &ref;
+            }
+            
+            inline Prop* addProp(CoreData const& data, Node* on_node)
+            {
+                Prop& ref = _props.emplace_back();
+                ref.data = data;
+                ref.flags = MetaFlags::Value_Kind_Prop;
+
+                on_node->props.push_back(&ref);
+                ref.owner = on_node;
+
+                return &ref;
+            }
+
+            inline Prop* addProp(CoreData const& data, Edge* on_edge)
+            {
+                Prop& ref = _props.emplace_back();
+                ref.data = data;
+                ref.flags = MetaFlags::Value_Kind_Prop;
+
+                on_edge->props.push_back(&ref);
+                ref.owner = on_edge;
+
+                return &ref;
+            }
+
+        // Update functions
+        public:
+            inline void attachLabel(Node* node, Label* label)
+            {
+                label->nodes.push_back(node);
+                node->labels.push_back(label);
+            }
+
+            inline void attachEdge(Node* node, Edge* edge)
+            {
+                edge->nodes.push_back(node);
+                node->edges.push_back(edge);
+            }
+
+            inline void attachEdge(Node* node, Edge* edge, size_t index)
+            {
+                if (index > edge->nodes.size())
+                    throw graph_error("Argument `index` out of range.");
+
+                edge->nodes.insert(edge->nodes.begin() + index, node);
+                node->edges.push_back(edge);
+            }
+
+        // Printer functions
+        public:
+            inline std::string print(Core*) const
+            {
+
+            }
+
+        // Stat functions
+        public:
+            inline size_t labelCount() const
+            {
+                return _labels.size();
+            }
+            inline size_t nodeCount() const
+            {
+                return _nodes.size();
+            }
+            inline size_t edgeCount() const
+            {
+                return _edges.size();
+            }
+            inline size_t propCount() const
+            {
+                return _props.size();
+            }
+
+        // Introspection functions
+        public:
+            
+            static inline bool isLabel(Core const* core)
+            {
+                return ((uint32_t)core->flags & (uint32_t)MetaFlags::Mask_Kind) == (uint32_t)MetaFlags::Value_Kind_Label;
+            }
+            static inline bool isNode(Core const* core)
+            {
+                return ((uint32_t)core->flags & (uint32_t)MetaFlags::Mask_Kind) == (uint32_t)MetaFlags::Value_Kind_Node;
+            }
+            static inline bool isEdge(Core const* core)
+            {
+                return ((uint32_t)core->flags & (uint32_t)MetaFlags::Mask_Kind) == (uint32_t)MetaFlags::Value_Kind_Edge;
+            }
+            static inline bool isProp(Core const* core)
+            {
+                return ((uint32_t)core->flags & (uint32_t)MetaFlags::Mask_Kind) == (uint32_t)MetaFlags::Value_Kind_Prop;
+            }
+
+            static inline bool isEdgeInverted(Edge const* edge)
+            {
+                return ((uint32_t)edge->flags & (uint32_t)MetaFlags::Flag_InverseEdge) != 0;
+            }
+
+        // Getter functions
+        public:
+            inline std::vector<Node*> getLabelNodes(Label const* label) const
+            {
+                return label->nodes;
+            }
+
+            inline std::vector<Label*> getNodeLabels(Node const* node) const
+            {
+                return node->labels;
+            }
+            inline std::vector<Edge*> getNodeEdges(Node const* node) const
+            {
+                return node->edges;
+            }
+            inline std::vector<Prop*> getNodeProps(Node const* node) const
+            {
+                return node->props;
+            }
+
+            inline std::vector<Node*> getEdgeNodes(Edge const* edge) const
+            {
+                return edge->nodes;
+            }
+            inline std::vector<Prop*> getEdgeProps(Edge const* edge) const
+            {
+                return edge->props;
+            }
+
+        // Iteration functions
+        public:
+            template<typename Func>
+            inline void forAllLabels(Func func) const
+            {
+                for (auto label_it = _labels.begin(); label_it != _labels.end(); ++label_it)
+                {
+                    if (!_detail::invoke_return_bool_or_true(func, (Label const*)&*label_it))
+                        break;
+                }
+            }
+
+            template<typename Func>
+            inline void forAllNodes(Func func) const
+            {
+                for (auto node_it = _nodes.begin(); node_it != _nodes.end(); ++node_it)
+                {
+                    if (!_detail::invoke_return_bool_or_true(func, (Node const*)&*node_it))
+                        break;
+                }
+            }
+
+            template<typename Func>
+            inline void forAllEdges(Func func) const
+            {
+                for (auto edge_it = _edges.begin(); edge_it != _edges.end(); ++edge_it)
+                {
+                    if (!_detail::invoke_return_bool_or_true(func, (Edge const*)*edge_it))
+                        break;
+                }
+            }
+
+            template<typename Func>
+            inline void forAllNodesInLabel(Label const* label, Func func) const
+            {
+                for (auto node_it = label->nodes.begin(); node_it != label->nodes.end(); ++node_it)
+                {
+                    if (!_detail::invoke_return_bool_or_true(func, (Node const*)*node_it))
+                        break;
+                }
+            }
+
+            template<typename Func>
+            inline void forAllLabelsOnNode(Node const* node, Func func) const
+            {
+                for (auto label_it = node->labels.begin(); label_it != node->labels.end(); ++label_it)
+                {
+                    if (!_detail::invoke_return_bool_or_true(func, (Label const*)*label_it))
+                        break;
+                }
+            }
+
+            template<typename Func>
+            inline void forAllEdgesOnNode(Node const* node, Func func) const
+            {
+                for (auto edge_it = node->edges.begin(); edge_it != node->edges.end(); ++edge_it)
+                {
+                    if (!_detail::invoke_return_bool_or_true(func, (Edge const*)*edge_it))
+                        break;
+                }
+            }
+
+            template<typename Func>
+            inline void forAllPropsOnNode(Node const* node, Func func) const
+            {
+                for (auto prop_it = node->props.begin(); prop_it != node->props.end(); ++prop_it)
+                {
+                    if (!_detail::invoke_return_bool_or_true(func, (Prop const*)*prop_it))
+                        break;
+                }
+            }
+
+            template<typename Func>
+            inline void forAllNodesInEdge(Edge const* edge, Func func) const
+            {
+                for (auto node_it = edge->nodes.begin(); node_it != edge->nodes.end(); ++node_it)
+                {
+                    if (!_detail::invoke_return_bool_or_true(func, (Node const*)*node_it))
+                        break;
+                }
+            }
+            
+            template<typename Func>
+            inline void forAllPropsOnEdge(Edge const* edge, Func func) const
+            {
+                for (auto prop_it = edge->props.begin(); prop_it != edge->props.end(); ++prop_it)
+                {
+                    if (!_detail::invoke_return_bool_or_true(func, (Prop const*)*prop_it))
+                        break;
+                }
+            }
+        };
+    };
+}
\ No newline at end of file
diff --git a/src/graph/model/final.hpp b/src/graph/model/final.hpp
new file mode 100644
index 0000000..646b14c
--- /dev/null
+++ b/src/graph/model/final.hpp
@@ -0,0 +1,49 @@
+#pragma once
+
+#include <map>
+#include <vector>
+#include <deque>
+
+namespace graph
+{
+    template<typename TGraphBase>
+    class GraphFinalizer final
+        : public TGraphBase
+    {
+    public:
+        /*
+         * All types listed here are expected to be forwarded by all 'Actual' types
+         */
+        
+        using MetaFlags = typename TGraphBase::MetaFlags;
+        using CoreData = typename TGraphBase::CoreData;
+
+        struct Label
+            : public TGraphBase::Core
+            , public TGraphBase::Label
+        { };
+
+        struct Node
+            : public TGraphBase::Core
+            , public TGraphBase::Node
+        { };
+
+        struct Edge
+            : public TGraphBase::Core
+            , public TGraphBase::Edge
+        { };
+
+        struct Prop
+            : public TGraphBase::Core
+            , public TGraphBase::Prop
+        { };
+    };
+
+    // This type realizes the graph
+    template<typename TGraphBase>
+    class Graph
+        : public TGraphBase::template Actual<GraphFinalizer<TGraphBase>>
+    {
+
+    };
+}
diff --git a/src/graph/model/todo.hpp b/src/graph/model/todo.hpp
new file mode 100644
index 0000000..ea26b29
--- /dev/null
+++ b/src/graph/model/todo.hpp
@@ -0,0 +1,47 @@
+#pragma once
+
+#include <vector>
+
+#include "../util.hpp"
+
+namespace graph
+{
+    // Provides a way to reference parent graphs, but keep changes local to this one
+    template<typename TGraphBase>
+    class GraphDifferentiated
+        : public TGraphBase
+    {
+    // Actual type:
+    public:
+        template<typename TFinal>
+        class Actual
+            : public TGraphBase::template Actual<TFinal>
+        {
+            using Base = typename TGraphBase::template Actual<TFinal>;
+
+        protected:
+
+            std::vector<TFinal*> _parents;
+        };
+    };
+
+    // Provides a way to name edges, nodes, labels, and props
+    // Along with effecient access patterns
+    template<typename TGraphBase>
+    class GraphNamed
+        : public TGraphBase
+    {
+    // Actual type:
+    public:
+        template<typename TFinal>
+        class Actual
+            : public TGraphBase::template Actual<TFinal>
+        {
+            using Base = typename TGraphBase::template Actual<TFinal>;
+
+        protected:
+
+            std::vector<TFinal*> _parents;
+        };
+    };
+}
\ No newline at end of file
diff --git a/src/graph/model/typed.hpp b/src/graph/model/typed.hpp
new file mode 100644
index 0000000..4cb11d0
--- /dev/null
+++ b/src/graph/model/typed.hpp
@@ -0,0 +1,207 @@
+#pragma once
+
+#include <map>
+
+#include "../util.hpp"
+
+namespace graph
+{
+    template<typename TType, typename TData>
+    struct basic_typed_config
+        : basic_core_config<std::tuple<TData, TType>>
+    {
+        
+    };
+
+    /*
+     * This graph mixin adds typing to the graph. Each Core object has a type parameter.
+     * We pull from the config a set of functionality:
+     * - TypeId is the storage type for the type identifier
+     * - typed_typeToValue<T>()
+     */
+    template<typename TGraphBase>
+    class GraphTyped
+        : public TGraphBase
+    {
+    // Graph types:
+    public:
+        using Config = typename TGraphBase::Config;
+        using TypeId = typename Config::TypeId;
+
+        struct Core
+            : public TGraphBase::Core
+        {
+            TypeId type;
+        };
+
+        struct Label
+            : public TGraphBase::Label
+        {
+            std::map<TypeId, size_t> nodes_type_accel;
+        };
+
+        struct Node
+            : public TGraphBase::Node
+        {
+            std::map<TypeId, size_t> edges_type_accel;
+            std::map<TypeId, size_t> props_type_accel;
+        };
+
+        struct Edge
+            : public TGraphBase::Edge
+        {
+            std::map<TypeId, size_t> props_type_accel;
+        };
+        
+    // Actual type:
+    public:
+        template<typename TFinal>
+        class Actual
+            : private TGraphBase::template Actual<TFinal>
+        {
+            using Base = typename TGraphBase::template Actual<TFinal>;
+
+        public:
+            using MetaFlags = typename TFinal::MetaFlags;
+            using CoreData = typename TFinal::CoreData;
+
+            using Label = typename TFinal::Label;
+            using Node = typename TFinal::Node;
+            using Edge = typename TFinal::Edge;
+            using Prop = typename TFinal::Prop;
+
+        // Add functions
+        public:
+            inline Label* addLabel(CoreData const& data, TypeId type)
+            {
+                auto ret = Base::addLabel(data);
+                ret->type = type;
+
+                return ret;
+            }
+
+            template<typename T>
+            inline Label* addLabel(T const& data)
+            {
+                return addLabel(Config::template typed_store<T>(data), Config::template typed_typeToValue<T>());
+            }
+
+            inline Node* addNode(CoreData const& data, TypeId type)
+            {
+                auto ret = Base::addNode(data);
+                ret->type = type;
+
+                return ret;
+            }
+
+            template<typename T>
+            inline Node* addNode(T const& data)
+            {
+                return addNode(Config::template typed_store<T>(data), Config::template typed_typeToValue<T>());
+            }
+            
+            // By default edges point from 0-index to all others
+            inline Edge* addEdge(CoreData const& data, TypeId type, std::vector<Node*> const& nodes, bool invert = false)
+            {
+                auto ret = Base::addEdge(data, nodes, invert);
+                ret->type = type;
+
+                return ret;
+            }
+
+            template<typename T>
+            inline Edge* addEdge(T const& data, std::vector<Node*> const& nodes, bool invert = false)
+            {
+                return addEdge(Config::template typed_store<T>(data), Config::template typed_typeToValue<T>(), nodes, invert);
+            }
+            
+            inline Prop* addProp(CoreData const& data, TypeId type, Node* on_node)
+            {
+                auto ret = Base::addProp(data, on_node);
+                ret->type = type;
+
+                return ret;
+            }
+
+            template<typename T>
+            inline Prop* addProp(T const& data, Node* on_node)
+            {
+                return addProp(Config::template typed_store<T>(data), Config::template typed_typeToValue<T>(), on_node);
+            }
+
+            inline Prop* addProp(CoreData const& data, TypeId type, Edge* on_edge)
+            {
+                auto ret = Base::addProp(data, on_edge);
+                ret->type = type;
+
+                return ret;
+            }
+
+            template<typename T>
+            inline Prop* addProp(T const& data, Edge* on_edge)
+            {
+                return addProp(Config::template typed_store<T>(data), Config::template typed_typeToValue<T>(), on_edge);
+            }
+
+        // Getter functions
+        public:
+            using Base::labelCount;
+            using Base::nodeCount;
+            using Base::edgeCount;
+            using Base::propCount;
+
+            using Base::getNodeLabels;
+            using Base::getEdgeNodes;
+            using Base::isEdgeInverted;
+
+            TypeId getType(Core* core)
+            {
+                return core->type;
+            }
+
+        // Iteration functions
+        public:
+            using Base::forAllLabels;
+            using Base::forAllNodes;
+            using Base::forAllEdges;
+            using Base::forAllNodesInLabel;
+            using Base::forAllLabelsOnNode;
+            using Base::forAllEdgesOnNode;
+            using Base::forAllPropsOnNode;
+
+        // Update functions
+        public:
+            using Base::attachLabel;
+            using Base::attachEdge;
+
+            void attachType(Core* core, TypeId type)
+            {
+                core->type = type;
+            }
+
+        // Temporary
+        // TODO: Create a graph that uses types to compile time prove properties
+        // TODO: move the only functions there
+        public:
+            template<typename T>
+            T const* onlyPropOfTypeOnNode(Node const* node) const
+            {
+                auto searchType = Config::template typed_typeToValue<T>();
+                T const* result = nullptr;
+
+                forAllPropsOnNode(node,
+                    [&](auto prop) -> bool
+                    {
+                        if (prop->type == searchType)
+                        {
+                            result = Config::template typed_load<T>(prop->data);
+                            return false;
+                        }
+                        return true;
+                    });
+
+                return result;
+            }
+        };
+    };
+}
\ No newline at end of file
diff --git a/src/graph/query/engine.hpp b/src/graph/query/engine.hpp
new file mode 100644
index 0000000..9cac39d
--- /dev/null
+++ b/src/graph/query/engine.hpp
@@ -0,0 +1,314 @@
+#pragma once
+
+#include <memory>
+#include <variant>
+#include <vector>
+#include <set>
+#include <tuple>
+
+#include "../util.hpp"
+
+/*
+ * This file contains the query engine, which has the following parts:
+ * - Gremlin
+ * - Pipe - Base class
+ * - PipeLine - Container
+ *   - Including interpreter
+ */
+
+namespace graph
+{
+    template<typename TGraph>
+    class GraphQueryEngine final
+    {
+    public:
+        using Graph = TGraph;
+
+        class Gremlin
+        {
+        public:
+            typename TGraph::Node const* node;
+
+            std::map<size_t, typename TGraph::Node const*> labels;
+
+        public:
+            typename TGraph::Node const* getLabel(size_t label) const
+            {
+                auto it = labels.find(label);
+                if ( it == labels.end() )
+                    return nullptr;
+                else
+                    return it->second;
+            }
+        };
+
+        enum class PipeResultEnum
+        {
+            Done,
+            Pull
+        };
+
+        using PipeResult = std::variant<PipeResultEnum, std::shared_ptr<Gremlin>>;
+
+        class Pipe
+        {
+        protected:
+            friend class GraphQueryEngine<TGraph>;
+
+        public:
+            virtual ~Pipe() = default;
+
+        protected:
+            inline virtual Pipe* init() const { return const_cast<Pipe*>(this); };
+            inline virtual void cleanup() { delete this; };
+
+            inline virtual std::vector<std::shared_ptr<class PipeLine>> getSubPipelines() { return { }; };
+
+            virtual PipeResult pipeFunc(TGraph const* graph, std::shared_ptr<Gremlin> const& gremlin) = 0;
+        };
+
+        class PipeLine final
+        {
+            bool _isActive;
+            std::vector<std::unique_ptr<Pipe>> _pipes;
+            std::vector<Pipe*> _state;
+
+        public:
+            PipeLine()
+                : _isActive(false)
+                , _pipes()
+                , _state()
+            {
+            }
+
+            ~PipeLine()
+            {
+                reset();
+            }
+
+        public:
+            inline void addPipe(std::unique_ptr<Pipe> && pipe)
+            {
+                if (_isActive)
+                    throw graph_error("Pipeline is active.");
+                _pipes.push_back(std::move(pipe));
+            }
+
+            inline void ensureActive()
+            {
+                if (!_isActive)
+                {
+                    _state.reserve(_pipes.size());
+                    for (auto const& pipe : _pipes)
+                    {
+                        _state.push_back(pipe->init());
+                    }
+                    _isActive = true;
+                }
+            }
+
+            inline size_t countPipes() const
+            {
+                return _pipes.size();
+            }
+
+            inline void reset()
+            {
+                for (auto pipe : _state)
+                {
+                    pipe->cleanup();
+                }
+                _state.clear();
+                _isActive = false;
+            }
+
+            inline std::vector<std::shared_ptr<Gremlin>> run(TGraph* graph)
+            {
+                ensureActive();
+
+                // The results of the query
+                std::vector<std::shared_ptr<Gremlin>> results;
+
+                // We operate "one to the right" because we need sentinals on both sides.
+                const size_t max = _state.size();
+                size_t done = 0;
+                size_t pc = max;
+
+                PipeResult maybe_gremlin = nullGremlin();
+
+                while (done < max)
+                {
+                    auto gremlin = std::holds_alternative<std::shared_ptr<Gremlin>>(maybe_gremlin)
+                        ? std::get<std::shared_ptr<Gremlin>>(maybe_gremlin)
+                        : nullGremlin();
+
+                    maybe_gremlin = _state[pc - 1]->pipeFunc(graph, gremlin);
+
+                    auto maybe_gremlin_is_enum = std::holds_alternative<PipeResultEnum>(maybe_gremlin);
+                    if (maybe_gremlin_is_enum)
+                    {
+                        auto result_enum = std::get<PipeResultEnum>(maybe_gremlin);
+                        maybe_gremlin = nullGremlin();
+                        
+                        // Pipe needs more input
+                        if (result_enum == PipeResultEnum::Pull)
+                        {
+                            // Try the previous pipe
+                            if (pc - 1 > done)
+                            {
+                                pc --;
+                                continue;
+                            }
+                            // , the previous pipe is done then so is this one
+                            else
+                                done = pc;
+                        }
+                        // Pipe is finished
+                        else if (result_enum == PipeResultEnum::Done)
+                        {
+                            done = pc;
+                        }
+                    }
+
+                    // Move to next pipe
+                    pc ++; 
+
+                    if (pc > max)
+                    {
+                        // check for a gremlin that popped out
+                        if (!maybe_gremlin_is_enum)
+                        {
+                            auto gremlin = std::get<std::shared_ptr<Gremlin>>(maybe_gremlin);
+                            if (gremlin)
+                            {
+                                results.push_back(gremlin);
+                            }
+                        }
+
+                        // step back
+                        maybe_gremlin = nullGremlin();
+                        pc --;
+                    }
+                }
+
+                return results;
+            }
+        };
+
+    public:
+        static inline std::shared_ptr<Gremlin> makeGremlin(typename TGraph::Node const* node)
+        {
+            std::shared_ptr<Gremlin> ret = std::make_shared<Gremlin>();
+            ret->node = node;
+
+            return ret;
+        }
+        static inline std::shared_ptr<Gremlin> makeGremlin(typename TGraph::Node const* node, std::shared_ptr<Gremlin> const& original)
+        {
+            if (!original)
+                return makeGremlin(node);
+
+            std::shared_ptr<Gremlin> ret = std::make_shared<Gremlin>(*original);
+            ret->node = node;
+
+            return ret;
+        }
+        static inline std::shared_ptr<Gremlin> gotoVertex(std::shared_ptr<Gremlin> const& current, typename TGraph::Node const* node)
+        {
+            return makeGremlin(node, current);
+        }
+
+        static inline std::shared_ptr<Gremlin> nullGremlin()
+        {
+            return std::shared_ptr<Gremlin>();
+        }
+
+    // configure
+    private:
+        std::shared_ptr<PipeLine> _pipeline;
+
+        size_t _labelCounter;
+        std::map<std::string, size_t> _labels;
+
+    // state
+    private:
+        TGraph* _graph;
+
+    public:
+        GraphQueryEngine()
+            : _pipeline()
+            , _labelCounter(0)
+            , _labels()
+            , _graph(nullptr)
+        { }
+        GraphQueryEngine(TGraph* g)
+            : _pipeline()
+            , _labelCounter(0)
+            , _labels()
+            , _graph(g)
+        { }
+
+    public:
+        inline void reset()
+        {
+            if (_pipeline)
+                _pipeline->reset();
+        }
+
+        inline void setGraph(TGraph* g)
+        {
+            reset();
+            _graph = g;
+        }
+
+        inline TGraph* getGraph() const
+        {
+            return _graph;
+        }
+
+        inline void setPipeline(std::shared_ptr<PipeLine> pipeline)
+        {
+            reset();
+            _pipeline = pipeline;
+            reset();
+        }
+
+        inline std::shared_ptr<PipeLine> getPipeline() const
+        {
+            return _pipeline;
+        }
+
+        inline size_t requireLabel(std::string const& label)
+        {
+            auto lb = _labels.lower_bound(label);
+
+            if(lb != _labels.end() && !(_labels.key_comp()(label, lb->first)))
+            {
+                return lb->second;
+            }
+            else
+            {
+                auto id = ++_labelCounter;
+                _labels.insert(lb, typename decltype(_labels)::value_type(label, id));
+                return id;
+            }
+        }
+
+        inline std::vector<typename TGraph::Node const*> run()
+        {
+            auto results = _pipeline->run(_graph);
+
+            // TODO build a better way to map projected reuslts
+            // (perhaps by mutating query template and templating this function?)
+
+            std::vector<typename TGraph::Node const*> ret;
+            ret.reserve(results.size());
+            for (auto grem : results)
+            {
+                ret.push_back(grem->node);
+            }
+
+            return ret;
+        }
+    };
+}
diff --git a/src/graph/query/pipe_aggregation.hpp b/src/graph/query/pipe_aggregation.hpp
new file mode 100644
index 0000000..d92ab4a
--- /dev/null
+++ b/src/graph/query/pipe_aggregation.hpp
@@ -0,0 +1,57 @@
+#pragma once
+
+#include <memory>
+#include <set>
+
+#include "engine.hpp"
+
+namespace graph
+{
+
+    template<typename TGraph>
+    class GraphQueryPipeUnique
+        : public GraphQueryEngine<TGraph>::Pipe
+    {
+    private:
+        using Query = GraphQueryEngine<TGraph>;
+
+    // config
+    protected:
+
+    // state
+    protected:
+        std::set<typename TGraph::Node const*> _seen;
+
+    public:
+        inline GraphQueryPipeUnique()
+            : _seen()
+        { }
+
+        inline GraphQueryPipeUnique(GraphQueryPipeUnique const&) = default;
+        inline GraphQueryPipeUnique(GraphQueryPipeUnique &&) = default;
+
+        inline ~GraphQueryPipeUnique() = default;
+
+    protected:
+        virtual typename Query::Pipe* init() const override
+        {
+            auto res = new GraphQueryPipeUnique();
+
+            return res;
+        };
+
+        inline virtual typename Query::PipeResult pipeFunc(
+            TGraph const* graph,
+            std::shared_ptr<typename Query::Gremlin> const& gremlin
+        ) override
+        {
+            if (!gremlin)
+                return Query::PipeResultEnum::Pull;
+            if (_seen.count(gremlin->node))
+                return Query::PipeResultEnum::Pull;
+            _seen.insert(gremlin->node);
+            return gremlin;
+        }
+    };
+    
+}
\ No newline at end of file
diff --git a/src/graph/query/pipe_edge.hpp b/src/graph/query/pipe_edge.hpp
new file mode 100644
index 0000000..32a137d
--- /dev/null
+++ b/src/graph/query/pipe_edge.hpp
@@ -0,0 +1,146 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+#include <type_traits>
+
+#include "engine.hpp"
+
+namespace graph
+{
+
+    enum class GraphQueryPipeEdgesEnum
+    {
+        All,
+        Incoming,
+        Outgoing
+    };
+
+
+    template<typename TGraph, GraphQueryPipeEdgesEnum EMode, typename TFuncEdges, typename TFuncEdgeNodes>
+    class GraphQueryPipeEdges
+        : public GraphQueryEngine<TGraph>::Pipe
+    {
+    private:
+        using Query = GraphQueryEngine<TGraph>;
+
+    // config
+    protected:
+        TFuncEdges _func_edges;
+        TFuncEdgeNodes _func_edgeNodes;
+
+    // state
+    protected:
+        std::shared_ptr<typename Query::Gremlin> _gremlin;
+        std::vector<typename TGraph::Edge const*> _edges;
+        typename decltype(_edges)::const_iterator _edges_it;
+        std::vector<typename TGraph::Node const*> _nodes;
+        typename decltype(_nodes)::const_iterator _nodes_it;
+
+    public:
+        inline GraphQueryPipeEdges(TFuncEdges const& func_edges, TFuncEdgeNodes const& func_edgeNodes)
+            : _func_edges(func_edges)
+            , _func_edgeNodes(func_edgeNodes)
+            , _gremlin()
+            , _edges()
+            , _edges_it(_edges.end())
+            , _nodes()
+            , _nodes_it(_nodes.end())
+        { }
+
+        inline GraphQueryPipeEdges(GraphQueryPipeEdges const&) = default;
+        inline GraphQueryPipeEdges(GraphQueryPipeEdges &&) = default;
+
+        inline ~GraphQueryPipeEdges() = default;
+
+    protected:
+        virtual typename Query::Pipe* init() const override
+        {
+            auto res = new GraphQueryPipeEdges(*this);
+
+            return res;
+        };
+
+        static inline bool _modeFilterEdges(typename TGraph::Node const* n, typename TGraph::Edge const* e)
+        {
+            if constexpr (EMode == GraphQueryPipeEdgesEnum::All)
+            {
+                return true;
+            }
+            else if constexpr (EMode == GraphQueryPipeEdgesEnum::Incoming)
+            {
+                return edgeIsIncoming<TGraph>(n, e);
+            }
+            else if constexpr (EMode == GraphQueryPipeEdgesEnum::Outgoing)
+            {
+                return edgeIsOutgoing<TGraph>(n, e);
+            }
+            else
+            {
+                static_assert("Bad EMode");
+            }
+            
+        }
+
+        static inline bool _modeFilterEdgeNodes(typename TGraph::Node const* n, typename TGraph::Edge const* e, typename TGraph::Node const* en)
+        {
+            if constexpr (EMode == GraphQueryPipeEdgesEnum::All)
+            {
+                return n != en;
+            }
+            else if constexpr (EMode == GraphQueryPipeEdgesEnum::Incoming)
+            {
+                return !edgeIsIncoming<TGraph>(en, e);
+            }
+            else if constexpr (EMode == GraphQueryPipeEdgesEnum::Outgoing)
+            {
+                return !edgeIsOutgoing<TGraph>(en, e);
+            }
+            else
+            {
+                static_assert("Bad EMode");
+            }
+            
+        }
+
+        inline virtual typename Query::PipeResult pipeFunc(
+            TGraph const* graph,
+            std::shared_ptr<typename Query::Gremlin> const& gremlin
+        ) override
+        {
+            auto empty = _edges_it == _edges.end() && _nodes_it == _nodes.end();
+            if (!gremlin && empty)
+                return Query::PipeResultEnum::Pull;
+
+            // get a collection of edges on this node
+            if (empty) 
+            {
+                _gremlin = gremlin;
+
+                auto n = _gremlin->node;
+                _edges = collectEdges(*graph, n,
+                    [&](auto e) { return _modeFilterEdges(n, e) && _func_edges(n, e); });
+                _edges_it = _edges.begin();
+                _nodes_it = _nodes.end();
+            }
+
+            // pop to a new edge
+            while (_nodes_it == _nodes.end()) 
+            {
+                if (_edges_it == _edges.end())
+                    return Query::PipeResultEnum::Pull;
+
+                // TODO: simplyfy this, we know which nodes on the edge are the ones we want to
+                //   traverse, we may want to revert our iterator paradigm too.
+                auto n = _gremlin->node;
+                auto e = (typename TGraph::Edge const*) *(_edges_it ++);
+                _nodes = collectNodes(*graph, e, 
+                    [&](auto en) { return _modeFilterEdgeNodes(n, e, en) && _func_edgeNodes(n, e, en); });
+                _nodes_it = _nodes.begin();
+            }
+
+            return GraphQueryEngine<TGraph>::gotoVertex(_gremlin, (typename TGraph::Node const*) *(_nodes_it ++));
+        }
+    };
+    
+}
\ No newline at end of file
diff --git a/src/graph/query/pipe_empty.hpp b/src/graph/query/pipe_empty.hpp
new file mode 100644
index 0000000..e004742
--- /dev/null
+++ b/src/graph/query/pipe_empty.hpp
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <memory>
+
+#include "engine.hpp"
+
+namespace graph
+{
+
+    template<typename TGraph>
+    class GraphQueryPipeEmpty
+        : public GraphQueryEngine<TGraph>::Pipe
+    {
+    private:
+        using Query = GraphQueryEngine<TGraph>;
+
+    public:
+        inline GraphQueryPipeEmpty() = default;
+        inline GraphQueryPipeEmpty(GraphQueryPipeEmpty const&) = default;
+        inline GraphQueryPipeEmpty(GraphQueryPipeEmpty &&) = default;
+
+        inline ~GraphQueryPipeEmpty() = default;
+
+    protected:
+        inline virtual void cleanup() override { };
+
+        inline virtual typename Query::PipeResult pipeFunc(
+            TGraph const* graph,
+            std::shared_ptr<typename Query::Gremlin> const& gremlin
+        ) override
+        {
+            return gremlin
+                ? typename Query::PipeResult(gremlin)
+                : typename Query::PipeResult(Query::PipeResultEnum::Pull);
+        }
+    };
+    
+}
\ No newline at end of file
diff --git a/src/graph/query/pipe_filter.hpp b/src/graph/query/pipe_filter.hpp
new file mode 100644
index 0000000..ab63604
--- /dev/null
+++ b/src/graph/query/pipe_filter.hpp
@@ -0,0 +1,61 @@
+#pragma once
+
+#include <memory>
+#include <type_traits>
+
+#include "engine.hpp"
+
+namespace graph
+{
+
+    template<typename TGraph, typename TFuncNodes>
+    class GraphQueryPipeFilter
+        : public GraphQueryEngine<TGraph>::Pipe
+    {
+    private:
+        using Query = GraphQueryEngine<TGraph>;
+
+    // config
+    protected:
+        TFuncNodes _func_nodes;
+
+    // state
+    protected:
+
+    public:
+        inline GraphQueryPipeFilter(TFuncNodes const& func_nodes)
+            : _func_nodes(func_nodes)
+        { }
+
+        inline GraphQueryPipeFilter(GraphQueryPipeFilter const&) = default;
+        inline GraphQueryPipeFilter(GraphQueryPipeFilter &&) = default;
+
+        inline ~GraphQueryPipeFilter() = default;
+
+    protected:
+        inline virtual void cleanup() override { };
+
+        inline virtual typename Query::PipeResult pipeFunc(
+            TGraph const* graph,
+            std::shared_ptr<typename Query::Gremlin> const& gremlin
+        ) override
+        {
+            if (!gremlin)
+                return Query::PipeResultEnum::Pull;
+
+            bool filter_accepted;
+            if constexpr (std::is_invocable_v<TFuncNodes, decltype(gremlin->node)>)
+                filter_accepted = _func_nodes(gremlin->node);
+            else if constexpr (std::is_invocable_v<TFuncNodes, decltype(gremlin->node), decltype(gremlin)>)
+                filter_accepted = _func_nodes(gremlin->node, gremlin);
+            else
+                static_assert("TFuncNodes bad signature.");
+
+            if (filter_accepted)
+                return gremlin;
+            else
+                return Query::PipeResultEnum::Pull;
+        }
+    };
+
+}
\ No newline at end of file
diff --git a/src/graph/query/pipe_labels.hpp b/src/graph/query/pipe_labels.hpp
new file mode 100644
index 0000000..f123c8e
--- /dev/null
+++ b/src/graph/query/pipe_labels.hpp
@@ -0,0 +1,141 @@
+#pragma once
+
+#include <memory>
+
+#include "engine.hpp"
+
+/*
+ * This file contains the following pipe implementations
+ * - GraphQueryPipeLabel (AKA `as`)
+ * - GraphQueryPipeExcept (AKA `except`)
+ * - GraphQueryPipeBack (AKA `back`)
+ */
+
+namespace graph
+{
+
+    template<typename TGraph>
+    class GraphQueryPipeLabel
+        : public GraphQueryEngine<TGraph>::Pipe
+    {
+    private:
+        using Query = GraphQueryEngine<TGraph>;
+
+    // config
+    protected:
+        size_t _label;
+
+    // state
+    protected:
+
+    public:
+        inline GraphQueryPipeLabel(size_t label)
+            : _label(label)
+        { }
+
+        inline GraphQueryPipeLabel(GraphQueryPipeLabel const&) = default;
+        inline GraphQueryPipeLabel(GraphQueryPipeLabel &&) = default;
+
+        inline ~GraphQueryPipeLabel() = default;
+
+    protected:
+        inline virtual void cleanup() override { };
+
+        inline virtual typename Query::PipeResult pipeFunc(
+            TGraph const* graph,
+            std::shared_ptr<typename Query::Gremlin> const& gremlin
+        ) override
+        {
+            if (!gremlin)
+                return Query::PipeResultEnum::Pull;
+            
+            gremlin->labels[_label] = gremlin->node;
+
+            return gremlin;
+        }
+    };
+
+
+    template<typename TGraph>
+    class GraphQueryPipeExcept
+        : public GraphQueryEngine<TGraph>::Pipe
+    {
+    private:
+        using Query = GraphQueryEngine<TGraph>;
+
+    // config
+    protected:
+        size_t _label;
+
+    // state
+    protected:
+
+    public:
+        inline GraphQueryPipeExcept(size_t label)
+            : _label(label)
+        { }
+
+        inline GraphQueryPipeExcept(GraphQueryPipeExcept const&) = default;
+        inline GraphQueryPipeExcept(GraphQueryPipeExcept &&) = default;
+
+        inline ~GraphQueryPipeExcept() = default;
+
+    protected:
+        inline virtual void cleanup() override { };
+
+        inline virtual typename Query::PipeResult pipeFunc(
+            TGraph const* graph,
+            std::shared_ptr<typename Query::Gremlin> const& gremlin
+        ) override
+        {
+            if (!gremlin)
+                return Query::PipeResultEnum::Pull;
+            
+            if (gremlin->getLabel(_label) == gremlin->node)
+                return Query::PipeResultEnum::Pull;
+
+            return gremlin;
+        }
+    };
+
+
+    template<typename TGraph>
+    class GraphQueryPipeBack
+        : public GraphQueryEngine<TGraph>::Pipe
+    {
+    private:
+        using Query = GraphQueryEngine<TGraph>;
+
+    // config
+    protected:
+        size_t _label;
+
+    // state
+    protected:
+
+    public:
+        inline GraphQueryPipeBack(size_t label)
+            : _label(label)
+        { }
+
+        inline GraphQueryPipeBack(GraphQueryPipeBack const&) = default;
+        inline GraphQueryPipeBack(GraphQueryPipeBack &&) = default;
+
+        inline ~GraphQueryPipeBack() = default;
+
+    protected:
+        inline virtual void cleanup() override { };
+
+        inline virtual typename Query::PipeResult pipeFunc(
+            TGraph const* graph,
+            std::shared_ptr<typename Query::Gremlin> const& gremlin
+        ) override
+        {
+            if (!gremlin)
+                return Query::PipeResultEnum::Pull;
+            
+            return GraphQueryEngine<TGraph>::gotoVertex(gremlin, gremlin->getLabel(_label));
+        }
+    };
+
+}
\ No newline at end of file
diff --git a/src/graph/query/pipe_vertex.hpp b/src/graph/query/pipe_vertex.hpp
new file mode 100644
index 0000000..6314f70
--- /dev/null
+++ b/src/graph/query/pipe_vertex.hpp
@@ -0,0 +1,62 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "engine.hpp"
+
+namespace graph
+{
+
+    template<typename TGraph>
+    class GraphQueryPipeVertex
+        : public GraphQueryEngine<TGraph>::Pipe
+    {
+    private:
+        using Query = GraphQueryEngine<TGraph>;
+
+    // config
+    protected:
+        std::vector<typename TGraph::Node const*> _nodes;
+
+    // state
+    protected:
+        typename decltype(_nodes)::iterator _it;
+
+    public:
+        inline GraphQueryPipeVertex(std::vector<typename TGraph::Node const*> nodes)
+            : _nodes(nodes)
+            , _it(_nodes.end())
+        { }
+        inline GraphQueryPipeVertex(typename TGraph::Node const* node)
+            : _nodes({node})
+            , _it(_nodes.end())
+        { }
+
+        inline GraphQueryPipeVertex(GraphQueryPipeVertex const&) = default;
+        inline GraphQueryPipeVertex(GraphQueryPipeVertex &&) = default;
+
+        inline ~GraphQueryPipeVertex() = default;
+
+    protected:
+        virtual typename Query::Pipe* init() const override
+        {
+            auto res = new GraphQueryPipeVertex(_nodes);
+            res->_it = res->_nodes.begin();
+
+            return res;
+        };
+
+        inline virtual typename Query::PipeResult pipeFunc(
+            TGraph const* graph,
+            std::shared_ptr<typename Query::Gremlin> const& gremlin
+        ) override
+        {
+            if (_it == _nodes.end())
+                return Query::PipeResultEnum::Done;
+            else
+                return GraphQueryEngine<TGraph>::makeGremlin(*(_it ++), gremlin);
+        }
+    };
+
+}
\ No newline at end of file
diff --git a/src/graph/query/query.hpp b/src/graph/query/query.hpp
new file mode 100644
index 0000000..45151e6
--- /dev/null
+++ b/src/graph/query/query.hpp
@@ -0,0 +1,83 @@
+#pragma once
+
+#include "engine.hpp"
+
+namespace graph
+{
+    template<typename TGraph, typename TQueryFinal>
+    class GraphQueryLibraryBase
+    {
+    protected:
+        virtual std::shared_ptr<GraphQueryEngine<TGraph>> & engine() = 0;
+        
+        virtual TQueryFinal addPipe(std::unique_ptr<typename GraphQueryEngine<TGraph>::Pipe> && Pipe) = 0;
+
+        virtual TQueryFinal newQueryPipeline() = 0;
+        virtual std::shared_ptr<typename GraphQueryEngine<TGraph>::PipeLine> extractPipeline(TQueryFinal const& other) = 0;
+    };
+
+    template<typename TGraph, template <typename, typename> typename TGraphQueryLibrary> 
+    class GraphQuery final
+        : public TGraphQueryLibrary<TGraph, GraphQuery<TGraph, TGraphQueryLibrary>>
+    {
+    private:
+        std::shared_ptr<GraphQueryEngine<TGraph>> _engine;
+        std::shared_ptr<typename GraphQueryEngine<TGraph>::PipeLine> _pipeline;
+
+        // subquery
+        GraphQuery(std::shared_ptr<GraphQueryEngine<TGraph>> & engine)
+        {
+            _engine = engine;
+            _pipeline = std::make_shared<typename GraphQueryEngine<TGraph>::PipeLine>();
+        }
+
+    protected:
+        inline virtual std::shared_ptr<GraphQueryEngine<TGraph>> & engine() override
+        {
+            return _engine;
+        }
+        inline virtual GraphQuery addPipe(std::unique_ptr<typename GraphQueryEngine<TGraph>::Pipe> && Pipe) override
+        {
+            _pipeline->addPipe(std::move(Pipe));
+
+            return std::move(*this);
+        }
+        
+        inline virtual GraphQuery newQueryPipeline() override
+        {
+            return GraphQuery(_engine);
+        }
+        inline virtual std::shared_ptr<typename GraphQueryEngine<TGraph>::PipeLine> extractPipeline(GraphQuery const& query)
+        {
+            return query._pipeline;
+        }
+
+
+    public:
+        GraphQuery(TGraph* g)
+        {
+            _engine = std::make_shared<GraphQueryEngine<TGraph>>(g);
+            _pipeline = std::make_shared<typename GraphQueryEngine<TGraph>::PipeLine>();
+            _engine->setPipeline(_pipeline);
+        }
+
+        ~GraphQuery() = default;
+
+        GraphQuery(GraphQuery&& that) = default;
+        GraphQuery& operator=(GraphQuery&& other) = default;
+
+        GraphQuery(GraphQuery const& that) = delete;
+        GraphQuery& operator=(const GraphQuery& other) = delete;
+
+        inline GraphQueryEngine<TGraph>* operator->()
+        {
+            return _engine.operator->();
+        }
+
+        inline std::vector<typename TGraph::Node const*> run()
+        {
+            // TODO template magic to pass query template outs
+            return _engine->run();
+        }
+    };
+}
diff --git a/src/graph/query/query_library_core.hpp b/src/graph/query/query_library_core.hpp
new file mode 100644
index 0000000..d0d60e7
--- /dev/null
+++ b/src/graph/query/query_library_core.hpp
@@ -0,0 +1,87 @@
+#pragma once
+
+#include "query.hpp"
+
+#include "pipe_empty.hpp"
+#include "pipe_vertex.hpp"
+#include "pipe_edge.hpp"
+#include "pipe_filter.hpp"
+#include "pipe_aggregation.hpp"
+#include "pipe_labels.hpp"
+
+namespace graph
+{
+    template<typename TGraph, typename TQueryFinal>
+    class GraphQueryLibraryCore
+        : protected GraphQueryLibraryBase<TGraph, TQueryFinal>
+    {
+    public:
+        template<typename ...TArgs>
+        TQueryFinal v(TArgs... args)
+        {
+            return this->addPipe(std::make_unique<GraphQueryPipeVertex<TGraph>>(std::forward<TArgs>(args)...));
+        }
+
+        template<typename TFuncEdges>
+        TQueryFinal e(TFuncEdges func_edges)
+        {
+            auto edgeNodeFunc = [](auto n, auto e, auto ne){ return true; };
+            return this->addPipe(std::make_unique<GraphQueryPipeEdges<TGraph, GraphQueryPipeEdgesEnum::All, TFuncEdges, decltype(edgeNodeFunc)>>(std::forward<TFuncEdges>(func_edges), edgeNodeFunc));
+        }
+        template<typename TFuncEdges, typename TFuncEdgeNodes>
+        TQueryFinal e(TFuncEdges func_edges, TFuncEdgeNodes func_edgeNodes)
+        {
+            return this->addPipe(std::make_unique<GraphQueryPipeEdges<TGraph, GraphQueryPipeEdgesEnum::All, TFuncEdges, TFuncEdgeNodes>>(std::forward<TFuncEdges>(func_edges), std::forward<TFuncEdgeNodes>(func_edgeNodes)));
+        }
+
+        template<typename TFuncEdges>
+        TQueryFinal in(TFuncEdges func_edges)
+        {
+            auto inEdgeNodeFunc = [](auto n, auto e, auto ne){ return true; };
+            return this->addPipe(std::make_unique<GraphQueryPipeEdges<TGraph, GraphQueryPipeEdgesEnum::Incoming, TFuncEdges, decltype(inEdgeNodeFunc)>>(std::forward<TFuncEdges>(func_edges), inEdgeNodeFunc));
+        }
+        template<typename TFuncEdges, typename TFuncEdgeNodes>
+        TQueryFinal in(TFuncEdges func_edges, TFuncEdgeNodes func_edgeNodes)
+        {
+            return this->addPipe(std::make_unique<GraphQueryPipeEdges<TGraph, GraphQueryPipeEdgesEnum::Incoming, TFuncEdges, TFuncEdgeNodes>>(std::forward<TFuncEdges>(func_edges), std::forward<TFuncEdgeNodes>(func_edgeNodes)));
+        }
+
+        template<typename TFuncEdges>
+        TQueryFinal out(TFuncEdges func_edges)
+        {
+            auto outEdgeNodeFunc = [](auto n, auto e, auto ne){ return true; };
+            return this->addPipe(std::make_unique<GraphQueryPipeEdges<TGraph, GraphQueryPipeEdgesEnum::Outgoing, TFuncEdges, decltype(outEdgeNodeFunc)>>(std::forward<TFuncEdges>(func_edges), outEdgeNodeFunc));
+        }
+        template<typename TFuncEdges, typename TFuncEdgeNodes>
+        TQueryFinal out(TFuncEdges func_edges, TFuncEdgeNodes func_edgeNodes)
+        {
+            return this->addPipe(std::make_unique<GraphQueryPipeEdges<TGraph, GraphQueryPipeEdgesEnum::Outgoing, TFuncEdges, TFuncEdgeNodes>>(std::forward<TFuncEdges>(func_edges), std::forward<TFuncEdgeNodes>(func_edgeNodes)));
+        }
+
+        template<typename TFuncNodes>
+        TQueryFinal filter(TFuncNodes func_nodes)
+        {
+            return this->addPipe(std::make_unique<GraphQueryPipeFilter<TGraph, TFuncNodes>>(std::forward<TFuncNodes>(func_nodes)));
+        }
+        
+        TQueryFinal unique()
+        {
+            return this->addPipe(std::make_unique<GraphQueryPipeUnique<TGraph>>());
+        }
+
+        TQueryFinal as(std::string const& label)
+        {
+            return this->addPipe(std::make_unique<GraphQueryPipeLabel<TGraph>>(this->engine()->requireLabel(label)));
+        }
+
+        TQueryFinal except(std::string const& label)
+        {
+            return this->addPipe(std::make_unique<GraphQueryPipeExcept<TGraph>>(this->engine()->requireLabel(label)));
+        }
+
+        TQueryFinal back(std::string const& label)
+        {
+            return this->addPipe(std::make_unique<GraphQueryPipeBack<TGraph>>(this->engine()->requireLabel(label)));
+        }
+    };
+}
\ No newline at end of file
diff --git a/src/graph/util.hpp b/src/graph/util.hpp
new file mode 100644
index 0000000..75d7579
--- /dev/null
+++ b/src/graph/util.hpp
@@ -0,0 +1,37 @@
+#pragma once
+
+#include <stdexcept>
+
+namespace graph
+{
+    class graph_error
+        : public std::runtime_error
+    {
+        using std::runtime_error::runtime_error;
+    };
+
+    namespace _detail
+    {
+        template<typename Func,
+            typename... Args>
+        inline bool invoke_return_bool_or_true(Func func, Args&& ...args)
+        {
+            if constexpr (std::is_void<typename std::invoke_result<Func, Args...>::type>::value)
+            {
+                func(std::forward<Args>(args)...);
+                return true;
+            }
+            else
+                return func(std::forward<Args>(args)...);
+        }
+    }
+
+    enum class GraphKind : uint8_t
+    {
+        Unknown = 0,
+        Label = 1,
+        Node = 2,
+        Edge = 3,
+        Prop = 4,
+    };
+}
\ No newline at end of file
diff --git a/test/graph_algo.cpp b/test/graph_algo.cpp
new file mode 100644
index 0000000..7c4fd10
--- /dev/null
+++ b/test/graph_algo.cpp
@@ -0,0 +1,21 @@
+#include "catch2/catch.hpp"
+
+#include "shared.h"
+
+#include "graph/graph.hpp"
+
+#include <string>
+
+using namespace graph;
+using namespace Catch::Matchers;
+
+
+TEST_CASE( "graph::findNode", "[graph::findNode]" )
+{
+    test_help::str_graph g;
+
+    g.addNode("test");
+
+    CHECK(findNode(g, "test") != nullptr);
+    CHECK(findNode(g, "not-test") == nullptr);
+}
diff --git a/test/graph_core.cpp b/test/graph_core.cpp
new file mode 100644
index 0000000..cc3f685
--- /dev/null
+++ b/test/graph_core.cpp
@@ -0,0 +1,173 @@
+#include "catch2/catch.hpp"
+
+#include "graph/graph.hpp"
+
+#include "shared.h"
+
+using namespace graph;
+using namespace Catch::Matchers;
+
+TEST_CASE( "::graph::GraphCore basic initialization, adding, and counts", "[graph::GraphCore]" )
+{
+    test_help::str_graph g;
+
+    REQUIRE(g.labelCount() == 0);
+    REQUIRE(g.nodeCount() == 0);
+    REQUIRE(g.edgeCount() == 0);
+    REQUIRE(g.propCount() == 0);
+
+    SECTION( "adding a label, only adds a node" )
+    {
+        g.addLabel("a-label");
+
+        CHECK(g.labelCount() == 1);
+        CHECK(g.nodeCount() == 0);
+        CHECK(g.edgeCount() == 0);
+        CHECK(g.propCount() == 0);
+    }
+
+    SECTION( "adding a node, only adds a node" )
+    {
+        g.addNode("a-node");
+
+        CHECK(g.labelCount() == 0);
+        CHECK(g.nodeCount() == 1);
+        CHECK(g.edgeCount() == 0);
+        CHECK(g.propCount() == 0);
+    }
+
+    SECTION( "adding an edge (only on nodes), only adds an edge" )
+    {
+        auto a = g.addNode("a-node");
+        auto b = g.addNode("b-node");
+
+        CHECK(g.labelCount() == 0);
+        CHECK(g.nodeCount() == 2);
+        CHECK(g.edgeCount() == 0);
+        CHECK(g.propCount() == 0);
+
+        auto e = g.addEdge("a-edge", { a, b });
+
+        CHECK(g.labelCount() == 0);
+        CHECK(g.nodeCount() == 2);
+        CHECK(g.edgeCount() == 1);
+        CHECK(g.propCount() == 0);
+    }
+
+    SECTION( "adding an edge with too few nodes excepts" )
+    {
+        auto a = g.addNode("a-node");
+
+        CHECK(g.labelCount() == 0);
+        CHECK(g.nodeCount() == 1);
+        CHECK(g.edgeCount() == 0);
+        CHECK(g.propCount() == 0);
+
+        SECTION( "0 nodes" )
+        {
+            REQUIRE_THROWS_AS( g.addEdge("a-edge", { }), graph_error );
+        }
+        SECTION( "1 node" )
+        {
+            REQUIRE_THROWS_AS( g.addEdge("a-edge", { a }), graph_error );
+        }
+
+        CHECK(g.labelCount() == 0);
+        CHECK(g.nodeCount() == 1);
+        CHECK(g.edgeCount() == 0);
+        CHECK(g.propCount() == 0);
+    }
+
+    SECTION( "adding a property (on node), only adds a property" )
+    {
+        auto n = g.addNode("a-node");
+
+        CHECK(g.labelCount() == 0);
+        CHECK(g.nodeCount() == 1);
+        CHECK(g.edgeCount() == 0);
+        CHECK(g.propCount() == 0);
+
+        auto p = g.addProp("a-prop", n);
+
+        CHECK(g.labelCount() == 0);
+        CHECK(g.nodeCount() == 1);
+        CHECK(g.edgeCount() == 0);
+        CHECK(g.propCount() == 1);
+    }
+
+    SECTION( "adding a property (on edge), only adds a property" )
+    {
+        auto a = g.addNode("a-node");
+        auto b = g.addNode("b-node");
+        auto e = g.addEdge("a-edge", { a, b });
+        
+        CHECK(g.labelCount() == 0);
+        CHECK(g.nodeCount() == 2);
+        CHECK(g.edgeCount() == 1);
+        CHECK(g.propCount() == 0);
+
+        auto p = g.addProp("a-prop", e);
+
+        CHECK(g.labelCount() == 0);
+        CHECK(g.nodeCount() == 2);
+        CHECK(g.edgeCount() == 1);
+        CHECK(g.propCount() == 1);
+    }
+}
+
+
+
+TEST_CASE( "::graph::GraphCore updates", "[graph::GraphCore]" )
+{
+    test_help::str_graph g;
+
+    auto l = g.addLabel("label");
+
+    auto n0 = g.addNode("node-0");
+    auto n1 = g.addNode("node-1");
+    auto n2 = g.addNode("node-2");
+    auto n3 = g.addNode("node-3");
+
+    auto e = g.addEdge("edge", { n0, n1 });
+
+    REQUIRE(g.labelCount() == 1);
+    REQUIRE(g.nodeCount() == 4);
+    REQUIRE(g.edgeCount() == 1);
+    REQUIRE(g.propCount() == 0);
+
+    // TODO
+    SECTION( "attaching a label to a node" )
+    {
+        g.attachLabel(n0, l);
+    }
+
+    SECTION( "attaching an edge to a node" )
+    {
+        g.attachEdge(n2, e);
+    }
+
+    SECTION( "attaching an edge to a node, inserted first" )
+    {
+        g.attachEdge(n3, e, 0);
+    }
+
+    SECTION( "attaching an edge to a node, inserted middle" )
+    {
+        g.attachEdge(n3, e, 1);
+    }
+
+    SECTION( "attaching an edge to a node, inserted last" )
+    {
+        g.attachEdge(n3, e, 2);
+    }
+
+    SECTION( "attaching an edge to a node, inserted out of range, error" )
+    {
+        REQUIRE_THROWS_AS( g.attachEdge(n3, e, 5), graph_error );
+    }
+
+    REQUIRE(g.labelCount() == 1);
+    REQUIRE(g.nodeCount() == 4);
+    REQUIRE(g.edgeCount() == 1);
+    REQUIRE(g.propCount() == 0);
+}
\ No newline at end of file
diff --git a/test/graph_query.cpp b/test/graph_query.cpp
new file mode 100644
index 0000000..c56ddf0
--- /dev/null
+++ b/test/graph_query.cpp
@@ -0,0 +1,303 @@
+#include "catch2/catch.hpp"
+
+#include "shared.h"
+
+#include "graph/graph.hpp"
+
+#include <string>
+
+using namespace graph;
+using namespace Catch::Matchers;
+
+
+TEST_CASE( "graph::query() basics", "[graph::GraphQuery]" )
+{
+    test_help::str_graph g;
+
+    test_help::fillStrGraphWithNorse(g);
+
+    SECTION( "graph::query() returns working query object" )
+    {
+        auto q = query(&g);
+
+        CHECK(q->getGraph() == &g);
+        CHECK(q->getPipeline()->countPipes() == 0);
+
+        auto r = q.run();
+
+        CHECK(r.size() == 0);
+    }
+
+    SECTION( "->addPipe() can add GraphQueryPipeEmpty manually" )
+    {
+        auto q = query(&g);
+
+        q->getPipeline()->addPipe(std::make_unique<GraphQueryPipeEmpty<decltype(g)>>());
+
+        CHECK(q->getGraph() == &g);
+        CHECK(q->getPipeline()->countPipes() == 1);
+
+        auto r = q.run();
+
+        CHECK(r.size() == 0);
+    }
+
+    SECTION( ".v() can add GraphQueryStepVertex (AKA `v`) with syntax (single node)" )
+    {
+        auto q = query(&g)
+            .v(findNode(g, "thor"));
+
+        CHECK(q->getGraph() == &g);
+        CHECK(q->getPipeline()->countPipes() == 1);
+        
+        auto r = q.run();
+
+        CHECK(r.size() == 1);
+    }
+
+    SECTION( ".v() can add GraphQueryStepVertex (AKA `v`) with syntax (multiple nodes)" )
+    {
+        auto q = query(&g)
+            .v(std::vector { findNode(g, "thor"), findNode(g, "odin"), findNode(g, "jord") });
+
+        CHECK(q->getGraph() == &g);
+        CHECK(q->getPipeline()->countPipes() == 1);
+        
+        auto r = q.run();
+
+        CHECK(r.size() == 3);
+    }
+
+    SECTION( ".v() can add GraphQueryStepVertex (AKA `v`) with syntax (repeat nodes)" )
+    {
+        auto thor = findNode(g, "thor");
+        auto q = query(&g)
+            .v(std::vector { thor, thor, thor, thor, thor });
+
+        CHECK(q->getGraph() == &g);
+        CHECK(q->getPipeline()->countPipes() == 1);
+        
+        auto r = q.run();
+
+        CHECK(r.size() == 5);
+    }
+
+    SECTION( "after running a query, reset must be called to modify" )
+    {
+        auto q = query(&g);
+
+        q->getPipeline()->addPipe(std::make_unique<GraphQueryPipeEmpty<decltype(g)>>());
+
+        CHECK(q->getGraph() == &g);
+        CHECK(q->getPipeline()->countPipes() == 1);
+
+        auto r = q.run();
+
+        SECTION( "not doing so causes an exception" )
+        {
+            REQUIRE_THROWS_AS( q->getPipeline()->addPipe(std::make_unique<GraphQueryPipeEmpty<decltype(g)>>()), graph_error );
+        }
+
+        q->reset();
+        q->getPipeline()->addPipe(std::make_unique<GraphQueryPipeEmpty<decltype(g)>>());
+
+        r = q.run();
+    }
+}
+
+
+TEST_CASE( "graph::query() syntax traversal queries", "[graph::GraphQuery]" )
+{
+    test_help::str_graph g;
+
+    test_help::fillStrGraphWithNorse(g);
+
+    SECTION( ".e() can query for specific edges." )
+    {
+        auto q = query(&g)
+            .v(findNode(g, "thor"))
+            // same as "out" (mostly)
+            .e( [](auto n, auto e) { return edgeIsOutgoing<decltype(g)>(n, e) && e->data == "parents"; } );
+
+        CHECK(q->getPipeline()->countPipes() == 2);
+        
+        auto r = q.run();
+
+        CHECK(r.size() == 2); // Thor has 2 parents
+    }
+
+    SECTION( ".e() can follow edges in a specific way." )
+    {
+        auto q_mom = query(&g)
+            .v(findNode(g, "thor"))
+            // same as "out" (mostly)
+            .e( [](auto n, auto e) { return edgeIsOutgoing<decltype(g)>(n, e) && e->data == "parents"; },
+                // mother is in slot 1 (size guard not needed: 2 size edges are guarnteed)
+                [](auto n, auto e, auto ne) { return e->nodes[1] == ne; });
+
+        auto q_dad = query(&g)
+            .v(findNode(g, "thor"))
+            // same as "out" (mostly)
+            .e( [](auto n, auto e) { return edgeIsOutgoing<decltype(g)>(n, e) && e->data == "parents"; },
+                // father is in slot 2 (size guard requried)
+                [](auto n, auto e, auto ne) { return e->nodes.size() > 2 && e->nodes[2] == ne; });
+
+        CHECK(q_mom->getPipeline()->countPipes() == 2);
+        CHECK(q_dad->getPipeline()->countPipes() == 2);
+        
+        auto r_mom = q_mom.run();
+        auto r_dad = q_dad.run();
+
+        REQUIRE(r_mom.size() == 1);
+        REQUIRE(r_mom[0]->data == "jord"); // Thor's mom
+
+        REQUIRE(r_dad.size() == 1);
+        REQUIRE(r_dad[0]->data == "odin"); // Thor's dad
+    }
+
+    SECTION( ".in() can get nodes of incoming edges." )
+    {
+        auto q = query(&g)
+            .v(findNode(g, "thor"))
+            .in( [](auto n, auto e) { return e->data == "parents"; } );
+
+        CHECK(q->getPipeline()->countPipes() == 2);
+        
+        auto r = q.run();
+
+        CHECK(r.size() == 3); // Thor has 3 children
+    }
+
+    SECTION( ".out() can get nodes of outgoing edges." )
+    {
+        auto q = query(&g)
+            .v(findNode(g, "thor"))
+            .out( [](auto n, auto e) { return e->data == "parents"; } );
+
+        CHECK(q->getPipeline()->countPipes() == 2);
+        
+        auto r = q.run();
+
+        CHECK(r.size() == 2); // Thor has 2 parents
+    }
+
+    SECTION( ".filter() can filter nodes (1 arg, contrived)." )
+    {
+        auto q = query(&g)
+            .v(std::vector { findNode(g, "thor"), findNode(g, "odin"), findNode(g, "odr") })
+            .filter( [](auto n) { return n->data[0] != 'o'; } );
+
+        CHECK(q->getPipeline()->countPipes() == 2);
+        
+        auto r = q.run();
+
+        REQUIRE(r.size() == 1);
+        CHECK(r[0]->data == "thor");
+    }
+
+    SECTION( ".filter() can filter gremlins (2 arg, contrived)." )
+    {
+        auto q = query(&g)
+            .v(std::vector { findNode(g, "thor"), findNode(g, "odin"), findNode(g, "odr") })
+            .filter( [](auto n, auto g) { return g->node->data[0] != 'o'; } );
+
+        CHECK(q->getPipeline()->countPipes() == 2);
+        
+        auto r = q.run();
+
+        REQUIRE(r.size() == 1);
+        CHECK(r[0]->data == "thor");
+    }
+
+    SECTION( ".unique() ensures unique results (contrived)" )
+    {
+        auto thor = findNode(g, "thor");
+        auto q = query(&g)
+            .v(std::vector { thor, thor, thor, thor, thor })
+            .unique();
+
+        CHECK(q->getPipeline()->countPipes() == 2);
+
+        auto r = q.run();
+
+        REQUIRE(r.size() == 1); // Thor is unique
+    }
+
+    SECTION( ".unique() ensures unique results (large query)" )
+    {
+        auto q = query(&g)
+            .v(findNode(g, "thor"))
+            .out( [](auto n, auto e) { return e->data == "parents"; } )
+            .in( [](auto n, auto e) { return e->data == "parents"; } );
+
+        CHECK(q->getPipeline()->countPipes() == 3);
+
+        auto r0 = q.run();
+
+        q->reset();
+        q = q.unique();
+
+        CHECK(q->getPipeline()->countPipes() == 4);
+
+        auto r1 = q.run();
+
+        REQUIRE(r0.size() > r1.size());
+        REQUIRE(r1.size() == 4); // Thor has 4 siblings (including himself)
+    }
+}
+
+TEST_CASE( "graph::query() syntax label queries", "[graph::GraphQuery]" )
+{
+    test_help::str_graph g;
+
+    test_help::fillStrGraphWithNorse(g);
+
+    SECTION( ".as() can label nodes (contrived)" )
+    {
+        auto q = query(&g)
+            .v(findNode(g, "thor"))
+            .as("me");
+
+        CHECK(q->getPipeline()->countPipes() == 2);
+
+        auto r = q.run();
+
+        REQUIRE(r.size() == 1); // Thor is returned
+    }
+
+    SECTION( ".except() can filter based on labels (large query)" )
+    {
+        auto q = query(&g)
+            .v(findNode(g, "thor"))
+            .as("me")
+            .out( [](auto n, auto e) { return e->data == "parents"; } )
+            .in( [](auto n, auto e) { return e->data == "parents"; } )
+            .unique()
+            .except("me");
+
+        CHECK(q->getPipeline()->countPipes() == 6);
+
+        auto r = q.run();
+
+        REQUIRE(r.size() == 3); // Thor has 3 siblings
+    }
+
+    SECTION( ".back() can allow backtracking (large query)" )
+    {
+        auto q = query(&g)
+            .v(findNode(g, "fjorgynn"))
+            .in( [](auto n, auto e) { return e->data == "parents"; } )
+                .as("me")
+                    .in( [](auto n, auto e) { return e->data == "parents"; } )
+                    .out( [](auto n, auto e) { return e->data == "parents"; } )
+                    .out( [](auto n, auto e) { return e->data == "parents"; } )
+                    .filter( [](auto n) { return n->data == "bestla"; } )
+            .back("me").unique()
+            ;
+
+        auto r = q.run();
+
+        REQUIRE(r.size() == 1);
+        CHECK(r[0]->data == "frigg"); // frigg is the daughter of fjorgynn who had children with one of bestla's sons
+    }
+}
\ No newline at end of file
diff --git a/test/main.cpp b/test/main.cpp
new file mode 100644
index 0000000..5124593
--- /dev/null
+++ b/test/main.cpp
@@ -0,0 +1,2 @@
+#define CATCH_CONFIG_MAIN  // This tells Catch to provide a main() - only do this in one cpp file
+#include "catch2/catch.hpp"
\ No newline at end of file
diff --git a/test/shared.cpp b/test/shared.cpp
new file mode 100644
index 0000000..928983d
--- /dev/null
+++ b/test/shared.cpp
@@ -0,0 +1,133 @@
+#include "shared.h"
+
+using namespace graph;
+
+void test_help::fillStrGraphWithNorse(test_help::str_graph & g)
+{
+    // from http://www.veritablehokum.com/comic/the-norse-god-family-tree/
+
+    /* Data Model:
+     * - [Edges]
+     *   - parents: where possible is organized (child, mother, father)
+     */ 
+
+    // Helper temporaries
+    typename test_help::str_graph::Edge* e;
+
+
+    auto tyr = g.addNode("tyr");
+
+    auto mimir = g.addNode("mimir");
+
+    auto bestla = g.addNode("bestla");
+
+    auto burr = g.addNode("burr");
+
+    auto buri = g.addNode("buri");
+
+    e = g.addEdge("married", { burr, bestla });
+
+
+
+    // now it stops beign weird
+    auto fjorgynn = g.addNode("fjorgynn");
+    auto fjorgynn_wife = g.addNode("fjorgynn_wife");
+
+    auto vili = g.addNode("vili");
+    e = g.addEdge("parents", { vili, bestla, burr });
+
+    auto ve = g.addNode("ve");
+    e = g.addEdge("parents", { ve, bestla, burr });
+
+    auto hoenir = g.addNode("hoenir");
+    e = g.addEdge("parents", { hoenir, bestla, burr });
+
+
+
+    auto odin = g.addNode("odin");
+    e = g.addEdge("parents", { odin, bestla, burr });
+
+    auto jord = g.addNode("jord");
+
+    auto frigg = g.addNode("frigg");
+    e = g.addEdge("parents", { frigg, fjorgynn_wife, fjorgynn });
+
+    e = g.addEdge("married", { odin, frigg });
+
+
+
+    auto nanna = g.addNode("nanna");
+
+    auto baldr = g.addNode("baldr");
+
+    auto hodr = g.addNode("hodr");
+    e = g.addEdge("parents", { hodr, frigg, odin });
+
+    auto bragi = g.addNode("bragi");
+    e = g.addEdge("parents", { bragi, frigg, odin });
+
+    auto idunn = g.addNode("idunn");
+
+    e = g.addEdge("married", { baldr, nanna });
+
+
+
+    auto forseti = g.addNode("forseti");
+    e = g.addEdge("parents", { forseti, nanna, baldr });
+
+    auto sif = g.addNode("sif");
+
+    auto thor = g.addNode("thor");
+    e = g.addEdge("parents", { thor, jord, odin });
+
+    auto jarnsaxa = g.addNode("jarnsaxa");
+
+    e = g.addEdge("married", { thor, sif });
+
+
+
+
+    auto skadi = g.addNode("skadi");
+
+    auto njord = g.addNode("njord");
+
+    auto ullr = g.addNode("ullr");
+    e = g.addEdge("parents", { ullr, sif, odin });
+
+    auto modi = g.addNode("modi");
+    e = g.addEdge("parents", { modi, sif, thor });
+
+    auto thrud = g.addNode("thrud");
+    e = g.addEdge("parents", { thrud, sif, thor });
+
+    auto magni = g.addNode("magni");
+    e = g.addEdge("parents", { magni, jarnsaxa, thor });
+
+
+
+    auto gerdr = g.addNode("gerdr");
+
+    auto freyr = g.addNode("freyr");
+    e = g.addEdge("parents", { freyr, skadi, njord });
+
+    auto freya = g.addNode("freya");
+    e = g.addEdge("parents", { freya, skadi, njord });
+
+    auto odr = g.addNode("odr");
+
+    e = g.addEdge("married", { freyr, gerdr });
+    e = g.addEdge("married", { odr, freya });
+}
+
+
+
+#include "catch2/catch.hpp"
+
+using namespace Catch::Matchers;
+
+TEST_CASE( "test_help works correctly", "[test_help]" )
+{
+    test_help::str_graph g;
+
+    test_help::fillStrGraphWithNorse(g);
+}
\ No newline at end of file
diff --git a/test/shared.h b/test/shared.h
new file mode 100644
index 0000000..8ae8cd7
--- /dev/null
+++ b/test/shared.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include "graph/graph.hpp"
+
+#include <string>
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-variable"
+#endif
+
+namespace test_help
+{
+    using str_graph = graph::Graph< graph::GraphCore< graph::basic_core_config<std::string> > >;
+
+    void fillStrGraphWithNorse(str_graph & g);
+}