diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8c40401..bfe9bd0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -36,6 +36,7 @@ set(DULCIFICUM_SRC
         src/proto_path/translate.cpp
 
         src/utils/io.cpp
+        src/utils/svtod.cpp
         src/command_types.cpp
 )
 add_library(dulcificum ${DULCIFICUM_SRC})
diff --git a/include/dulcificum/gcode/ast/acceleration.h b/include/dulcificum/gcode/ast/acceleration.h
index 029f890..043728d 100644
--- a/include/dulcificum/gcode/ast/acceleration.h
+++ b/include/dulcificum/gcode/ast/acceleration.h
@@ -3,6 +3,8 @@
 
 #include "dulcificum/gcode/ast/entry.h"
 
+#include <optional>
+
 namespace dulcificum::gcode::ast
 {
 /*!
@@ -10,12 +12,14 @@ namespace dulcificum::gcode::ast
  * P = Printing acceleration. Used for moves that include extrusion
  * T = Travel acceleration. Used for moves that include no extrusion
  */
-class M204 : public Entry<R"(M204((?:\sP(?<P>\d+(?:\.\d+)?))|(?:\sT(?<T>\d+(?:\.\d+)?)))*$)">
+class M204 : public Entry<R"(M204((?:\sP(?<P>\d+(?:\.\d+)?))|(?:\sT(?<T>\d+(?:\.\d+)?))|(?:\sS(?<S>\d+(?:\.\d+)?)))*$)">
 {
 public:
     M204() = delete;
-    M204(size_t index, std::string line)
-        : Entry{ index, std::move(line) } {};
+    M204(size_t index, std::string line);
+    std::optional<double> P;
+    std::optional<double> T;
+    std::optional<double> S;
 };
 
 /*!
@@ -25,12 +29,15 @@ class M204 : public Entry<R"(M204((?:\sP(?<P>\d+(?:\.\d+)?))|(?:\sT(?<T>\d+(?:\.
  * Z = Z max jerk (units/s)
  * E = E max jerk (units/s)
  */
-class M205 : public Entry<R"(M205((?:\sX(?<X>\d+(?:\.\d+)?))|(?:\sY(?<Y>\d+(?:\.\d+)?))|(?:\sZ(?<Z>\d+(?:\.\d+)?))|(?:\sE(?<E>\d+(?:\.\d+)?)))*$)">
+class M205 : public Entry<R"(M205((?:\sX(?<X>-?\d+(?:\.\d+)?))|(?:\sY(?<Y>-?\d+(?:\.\d+)?))|(?:\sZ(?<Z>-?\d+(?:\.\d+)?))|(?:\sE(?<E>-?\d+(?:\.\d+)?)))*$)">
 {
 public:
     M205() = delete;
-    M205(size_t index, std::string line)
-        : Entry{ index, std::move(line) } {};
+    M205(size_t index, std::string line);
+    std::optional<double> X;
+    std::optional<double> Y;
+    std::optional<double> Z;
+    std::optional<double> E;
 };
 
 } // namespace dulcificum::gcode::ast
diff --git a/include/dulcificum/gcode/ast/bed_temperature.h b/include/dulcificum/gcode/ast/bed_temperature.h
index 2f66370..bb365aa 100644
--- a/include/dulcificum/gcode/ast/bed_temperature.h
+++ b/include/dulcificum/gcode/ast/bed_temperature.h
@@ -3,6 +3,8 @@
 
 #include "dulcificum/gcode/ast/entry.h"
 
+#include <optional>
+
 namespace dulcificum::gcode::ast
 {
 /*!
@@ -13,8 +15,8 @@ class M140 : public Entry<R"(M140((?:\sS(?<S>\d+(?:\.\d+)?)))*$)">
 {
 public:
     M140() = delete;
-    M140(size_t index, std::string line)
-        : Entry{ index, std::move(line) } {};
+    M140(size_t index, std::string line);
+    std::optional<double> S;
 };
 
 /*!
@@ -26,8 +28,9 @@ class M190 : public Entry<R"(M190((?:\sS(?<S>\d+(?:\.\d+)?))|(?:\sR(?<R>\d+(?:\.
 {
 public:
     M190() = delete;
-    M190(size_t index, std::string line)
-        : Entry{ index, std::move(line) } {};
+    M190(size_t index, std::string line);
+    std::optional<double> S;
+    std::optional<double> R;
 };
 } // namespace dulcificum::gcode::ast
 
diff --git a/include/dulcificum/gcode/ast/comment_commands.h b/include/dulcificum/gcode/ast/comment_commands.h
index 37bebfd..34a00ea 100644
--- a/include/dulcificum/gcode/ast/comment_commands.h
+++ b/include/dulcificum/gcode/ast/comment_commands.h
@@ -3,18 +3,20 @@
 
 #include "dulcificum/gcode/ast/entry.h"
 
+#include <optional>
+
 namespace dulcificum::gcode::ast
 {
 /*!
  * /brief The layer index
  * L = index
  */
-class Layer : public Entry<R"(;LAYER:(?<L>\d*))">
+class Layer : public Entry<R"(;LAYER:(?<L>-?\d+))">
 {
 public:
     Layer() = delete;
-    Layer(size_t index, std::string line)
-        : Entry{ index, std::move(line) } {};
+    Layer(size_t index, std::string line);
+    std::optional<size_t> L;
 };
 
 /*!
@@ -25,8 +27,8 @@ class Mesh : public Entry<R"(;MESH:(?<M>.*))">
 {
 public:
     Mesh() = delete;
-    Mesh(size_t index, std::string line)
-        : Entry{ index, std::move(line) } {};
+    Mesh(size_t index, std::string line);
+    std::optional<std::string_view> M;
 };
 
 /*!
@@ -37,8 +39,8 @@ class FeatureType : public Entry<R"(;TYPE:(?<T>.*))">
 {
 public:
     FeatureType() = delete;
-    FeatureType(size_t index, std::string line)
-        : Entry{ index, std::move(line) } {};
+    FeatureType(size_t index, std::string line);
+    std::optional<std::string_view> T;
 };
 
 /*!
@@ -50,8 +52,9 @@ class InitialTemperatureExtruder : public Entry<R"(;EXTRUDER_TRAIN\.(?<T>\d)\.IN
 {
 public:
     InitialTemperatureExtruder() = delete;
-    InitialTemperatureExtruder(size_t index, std::string line)
-        : Entry{ index, std::move(line) } {};
+    InitialTemperatureExtruder(size_t index, std::string line);
+    std::optional<size_t> T;
+    std::optional<double> S;
 };
 
 /*!
@@ -62,8 +65,8 @@ class InitialTemperatureBuildPlate : public Entry<R"(;BUILD_PLATE.INITIAL_TEMPER
 {
 public:
     InitialTemperatureBuildPlate() = delete;
-    InitialTemperatureBuildPlate(size_t index, std::string line)
-        : Entry{ index, std::move(line) } {};
+    InitialTemperatureBuildPlate(size_t index, std::string line);
+    std::optional<double> S;
 };
 
 /*!
@@ -74,8 +77,8 @@ class BuildVolumeTemperature : public Entry<R"(;BUILD_VOLUME.TEMPERATURE:(?<S>([
 {
 public:
     BuildVolumeTemperature() = delete;
-    BuildVolumeTemperature(size_t index, std::string line)
-        : Entry{ index, std::move(line) } {};
+    BuildVolumeTemperature(size_t index, std::string line);
+    std::optional<double> S;
 };
 
 } // namespace dulcificum::gcode::ast
diff --git a/include/dulcificum/gcode/ast/entry.h b/include/dulcificum/gcode/ast/entry.h
index 3534ed5..4bb724b 100644
--- a/include/dulcificum/gcode/ast/entry.h
+++ b/include/dulcificum/gcode/ast/entry.h
@@ -3,19 +3,27 @@
 
 #include "dulcificum/utils/char_range_literal.h"
 
-#include <spdlog/spdlog.h>
-
+#include <array>
 #include <cstddef>
+#include <ctll/fixed_string.hpp>
 #include <ctre.hpp>
+#include <map>
 #include <string>
+#include <string_view>
+#include <tuple>
+#include <unordered_map>
+#include <utility>
+#include <variant>
 
 namespace dulcificum::gcode::ast
 {
 
-template<dulcificum::utils::CharRangeLiteral Pattern>
+template<utils::CharRangeLiteral Pattern>
 class Entry
 {
 public:
+    using value_type = std::map<std::string_view, std::variant<double, int, std::string_view>>;
+
     Entry() = delete;
     Entry(size_t index, std::string line)
         : index{ index }
@@ -23,15 +31,16 @@ class Entry
 
     size_t index;
     std::string line;
+    static inline constexpr ctll::fixed_string pattern{ Pattern.value };
 
     constexpr auto get()
     {
-        return ctre::match<Pattern.value>(line);
+        return ctre::match<pattern>(line);
     };
 
-    virtual constexpr void operator()()
+    virtual value_type operator()()
     {
-        spdlog::info("lino: {} -> {}", index, line);
+        return {};
     };
 };
 
diff --git a/include/dulcificum/gcode/ast/extruder_temperature.h b/include/dulcificum/gcode/ast/extruder_temperature.h
index eb995de..2a1ddc3 100644
--- a/include/dulcificum/gcode/ast/extruder_temperature.h
+++ b/include/dulcificum/gcode/ast/extruder_temperature.h
@@ -3,18 +3,21 @@
 
 #include "dulcificum/gcode/ast/entry.h"
 
+#include <optional>
+
 namespace dulcificum::gcode::ast
 {
 /*!
  * /brief Set a new target hot end temperature (non-blocking).
  * S = Target temperature
  */
-class M104 : public Entry<R"(M104((?:\sS(?<S>\d+(?:\.\d+)?)))*$)">
+class M104 : public Entry<R"(M104((?:\sS(?<S>\d+(?:\.\d+)?))|(?:\sT(?<T>\d+(?:\.\d+)?)))*$)">
 {
 public:
     M104() = delete;
-    M104(size_t index, std::string line)
-        : Entry{ index, std::move(line) } {};
+    M104(size_t index, std::string line);
+    std::optional<double> S;
+    std::optional<size_t> T;
 };
 
 /*!
@@ -22,12 +25,14 @@ class M104 : public Entry<R"(M104((?:\sS(?<S>\d+(?:\.\d+)?)))*$)">
  * R = Target temperature (wait for cooling or heating).
  * S = Target temperature (wait only when heating)
  */
-class M109 : public Entry<R"(M109((?:\sS(?<S>\d+(?:\.\d+)?))|(?:\sR(?<R>\d+(?:\.\d+)?)))*$)">
+class M109 : public Entry<R"(M109((?:\sS(?<S>\d+(?:\.\d+)?))|(?:\sR(?<R>\d+(?:\.\d+)?))|(?:\sT(?<T>\d+(?:\.\d+)?)))*$)">
 {
 public:
     M109() = delete;
-    M109(size_t index, std::string line)
-        : Entry{ index, std::move(line) } {};
+    M109(size_t index, std::string line);
+    std::optional<double> S;
+    std::optional<double> R;
+    std::optional<size_t> T;
 };
 } // namespace dulcificum::gcode::ast
 
diff --git a/include/dulcificum/gcode/ast/fan.h b/include/dulcificum/gcode/ast/fan.h
index bf8d43b..25e650a 100644
--- a/include/dulcificum/gcode/ast/fan.h
+++ b/include/dulcificum/gcode/ast/fan.h
@@ -3,6 +3,8 @@
 
 #include "dulcificum/gcode/ast/entry.h"
 
+#include <optional>
+
 namespace dulcificum::gcode::ast
 {
 /*!
@@ -13,8 +15,8 @@ class M106 : public Entry<R"(M106((?:\sS(?<S>\d+(?:\.\d+)?)))*$)">
 {
 public:
     M106() = delete;
-    M106(size_t index, std::string line)
-        : Entry{ index, std::move(line) } {};
+    M106(size_t index, std::string line);
+    std::optional<double> S;
 };
 
 /*!
diff --git a/include/dulcificum/gcode/ast/position.h b/include/dulcificum/gcode/ast/position.h
index 785ec28..efacaf3 100644
--- a/include/dulcificum/gcode/ast/position.h
+++ b/include/dulcificum/gcode/ast/position.h
@@ -3,6 +3,8 @@
 
 #include "dulcificum/gcode/ast/entry.h"
 
+#include <optional>
+
 namespace dulcificum::gcode::ast
 {
 /*!
@@ -12,12 +14,15 @@ namespace dulcificum::gcode::ast
  * Z = New Z axis position
  * E New extruder position
  */
-class G92 : public Entry<R"(G92((?:\sX(?<X>\d+(?:\.\d+)?))|(?:\sY(?<Y>\d+(?:\.\d+)?))|(?:\sZ(?<Z>\d+(?:\.\d+)?))|(?:\sE(?<E>\d+(?:\.\d+)?)))*$)">
+class G92 : public Entry<R"(G92((?:\sX(?<X>-?\d+(?:\.\d+)?))|(?:\sY(?<Y>-?\d+(?:\.\d+)?))|(?:\sZ(?<Z>-?\d+(?:\.\d+)?))|(?:\sE(?<E>-?\d+(?:\.\d+)?)))*$)">
 {
 public:
     G92() = delete;
-    G92(size_t index, std::string line)
-        : Entry{ index, std::move(line) } {};
+    G92(size_t index, std::string line);
+    std::optional<double> X;
+    std::optional<double> Y;
+    std::optional<double> Z;
+    std::optional<double> E;
 };
 } // namespace dulcificum::gcode::ast
 
diff --git a/include/dulcificum/gcode/ast/purge.h b/include/dulcificum/gcode/ast/purge.h
index 854d06a..49c83dc 100644
--- a/include/dulcificum/gcode/ast/purge.h
+++ b/include/dulcificum/gcode/ast/purge.h
@@ -3,6 +3,8 @@
 
 #include "dulcificum/gcode/ast/entry.h"
 
+#include <optional>
+
 namespace dulcificum::gcode::ast
 {
 /*!
@@ -12,8 +14,8 @@ class G280 : public Entry<R"(G280((?:\sS(?<S>\d+(?:\.\d+)?)))*$)">
 {
 public:
     G280() = delete;
-    G280(size_t index, std::string line)
-        : Entry{ index, std::move(line) } {};
+    G280(size_t index, std::string line);
+    std::optional<size_t> S;
 };
 } // namespace dulcificum::gcode::ast
 
diff --git a/include/dulcificum/gcode/ast/toolchange.h b/include/dulcificum/gcode/ast/toolchange.h
index 7a150c1..72a542a 100644
--- a/include/dulcificum/gcode/ast/toolchange.h
+++ b/include/dulcificum/gcode/ast/toolchange.h
@@ -8,12 +8,12 @@ namespace dulcificum::gcode::ast
 /*!
  * /brief Switch to the specified tool
  */
-class T : public Entry<R"(T(?<T>\d))">
+class T : public Entry<R"(T(?<S>\d))">
 {
 public:
     T() = delete;
-    T(size_t index, std::string line)
-        : Entry{ index, std::move(line) } {};
+    T(size_t index, std::string line);
+    std::optional<size_t> S;
 };
 } // namespace dulcificum::gcode::ast
 
diff --git a/include/dulcificum/gcode/ast/translate.h b/include/dulcificum/gcode/ast/translate.h
index d030284..225186d 100644
--- a/include/dulcificum/gcode/ast/translate.h
+++ b/include/dulcificum/gcode/ast/translate.h
@@ -3,6 +3,10 @@
 
 #include "dulcificum/gcode/ast/entry.h"
 
+#include <cstddef>
+#include <optional>
+#include <string>
+
 
 namespace dulcificum::gcode::ast
 {
@@ -14,14 +18,16 @@ namespace dulcificum::gcode::ast
  * E = An absolute or relative coordinate on the E axis (in current units).
  * F = The maximum movement rate of the move between the start and end point.
  */
-class G0 : public Entry<R"(G0((?:\sX(?<X>\d+(?:\.\d+)?))|(?:\sY(?<Y>\d+(?:\.\d+)?))|(?:\sZ(?<Z>\d+(?:\.\d+)?))|(?:\sE(?<E>\d+(?:\.\d+)?))|(?:\sF(?<F>\d+(?:\.\d+)?)))*$)">
+class G0 : public Entry<R"(G0((?:\sX(?<X>-?\d+(?:\.\d+)?))|(?:\sY(?<Y>-?\d+(?:\.\d+)?))|(?:\sZ(?<Z>-?\d+(?:\.\d+)?))|(?:\sE(?<E>-?\d+(?:\.\d+)?))|(?:\sF(?<F>-?\d+(?:\.\d+)?)))*$)">
 {
 public:
     G0() = delete;
-    G0(size_t index, std::string line)
-        : Entry{ index, std::move(line) } {};
-
-    void operator()() override final;
+    G0(size_t index, std::string line);
+    std::optional<double> X;
+    std::optional<double> Y;
+    std::optional<double> Z;
+    std::optional<double> E;
+    std::optional<double> F;
 };
 
 /*!
@@ -32,14 +38,16 @@ class G0 : public Entry<R"(G0((?:\sX(?<X>\d+(?:\.\d+)?))|(?:\sY(?<Y>\d+(?:\.\d+)
  * E = An absolute or relative coordinate on the E axis (in current units).
  * F = The maximum movement rate of the move between the start and end point.
  */
-class G1 : public Entry<R"(G1((?:\sX(?<X>\d+(?:\.\d+)?))|(?:\sY(?<Y>\d+(?:\.\d+)?))|(?:\sZ(?<Z>\d+(?:\.\d+)?))|(?:\sE(?<E>\d+(?:\.\d+)?))|(?:\sF(?<F>\d+(?:\.\d+)?)))*$)">
+class G1 : public Entry<R"(G1((?:\sX(?<X>-?\d+(?:\.\d+)?))|(?:\sY(?<Y>-?\d+(?:\.\d+)?))|(?:\sZ(?<Z>-?\d+(?:\.\d+)?))|(?:\sE(?<E>-?\d+(?:\.\d+)?))|(?:\sF(?<F>-?\d+(?:\.\d+)?)))*$)">
 {
 public:
     G1() = delete;
-    G1(size_t index, std::string line)
-        : Entry{ index, std::move(line) } {};
-
-    void operator()() override final;
+    G1(size_t index, std::string line);
+    std::optional<double> X;
+    std::optional<double> Y;
+    std::optional<double> Z;
+    std::optional<double> E;
+    std::optional<double> F;
 };
 
 } // namespace dulcificum::gcode::ast
diff --git a/include/dulcificum/utils/svtod.h b/include/dulcificum/utils/svtod.h
new file mode 100644
index 0000000..919a776
--- /dev/null
+++ b/include/dulcificum/utils/svtod.h
@@ -0,0 +1,13 @@
+#ifndef INCLUDE_DULCIFICUM_UTILS_SVTOD_H
+#define INCLUDE_DULCIFICUM_UTILS_SVTOD_H
+
+#include <string_view>
+
+namespace dulcificum::utils
+{
+
+double StringViewToDouble(std::string_view sv);
+
+} // namespace dulcificum::utils
+
+#endif // INCLUDE_DULCIFICUM_UTILS_SVTOD_H
diff --git a/src/gcode/ast/operators.cpp b/src/gcode/ast/operators.cpp
index 696402f..71e3be9 100644
--- a/src/gcode/ast/operators.cpp
+++ b/src/gcode/ast/operators.cpp
@@ -1,27 +1,280 @@
+#include "dulcificum/gcode/ast/acceleration.h"
+#include "dulcificum/gcode/ast/bed_temperature.h"
+#include "dulcificum/gcode/ast/comment_commands.h"
+#include "dulcificum/gcode/ast/extruder_temperature.h"
+#include "dulcificum/gcode/ast/fan.h"
+#include "dulcificum/gcode/ast/position.h"
+#include "dulcificum/gcode/ast/purge.h"
+#include "dulcificum/gcode/ast/toolchange.h"
 #include "dulcificum/gcode/ast/translate.h"
+#include "dulcificum/utils/svtod.h"
 
-#include <spdlog/spdlog.h>
-
+#include <fmt/format.h>
 
 namespace dulcificum::gcode::ast
 {
+BuildVolumeTemperature::BuildVolumeTemperature(size_t index, std::string line)
+    : Entry{ index, std::move(line) }
+{
+    const auto& matches = get();
+    if (const auto& value = matches.get<"S">())
+    {
+        S = utils::StringViewToDouble(value.to_view());
+    }
+    else
+    {
+        throw std::runtime_error(fmt::format("Unable to parse lino: {}", index));
+    }
+}
+
+FeatureType::FeatureType(size_t index, std::string line)
+    : Entry{ index, std::move(line) }
+{
+    const auto& matches = get();
+    if (const auto& value = matches.get<"T">())
+    {
+        T = value.to_view();
+    }
+    else
+    {
+        throw std::runtime_error(fmt::format("Unable to parse lino: {}", index));
+    }
+}
+
+G0::G0(size_t index, std::string line)
+    : Entry{ index, std::move(line) }
+{
+    const auto& matches = get();
+    // clang-format off
+    if (const auto& value = matches.get<"X">()) { X = utils::StringViewToDouble(value.to_view()); }
+    if (const auto& value = matches.get<"Y">()) { Y = utils::StringViewToDouble(value.to_view()); }
+    if (const auto& value = matches.get<"Z">()) { Z = utils::StringViewToDouble(value.to_view()); }
+    if (const auto& value = matches.get<"E">()) { E = utils::StringViewToDouble(value.to_view()); }
+    if (const auto& value = matches.get<"F">()) { F = utils::StringViewToDouble(value.to_view()); }
+    // clang-format on
+    if (X == std::nullopt && Y == std::nullopt && Z == std::nullopt && E == std::nullopt && F == std::nullopt)
+    {
+        throw std::runtime_error(fmt::format("Unable to parse lino: {}", index));
+    }
+}
+
+G1::G1(size_t index, std::string line)
+    : Entry{ index, std::move(line) }
+{
+    const auto& matches = get();
+    // clang-format off
+    if (const auto& value = matches.get<"X">()) { X = utils::StringViewToDouble(value.to_view()); }
+    if (const auto& value = matches.get<"Y">()) { Y = utils::StringViewToDouble(value.to_view()); }
+    if (const auto& value = matches.get<"Z">()) { Z = utils::StringViewToDouble(value.to_view()); }
+    if (const auto& value = matches.get<"E">()) { E = utils::StringViewToDouble(value.to_view()); }
+    if (const auto& value = matches.get<"F">()) { F = utils::StringViewToDouble(value.to_view()); }
+    // clang-format on
+    if (X == std::nullopt && Y == std::nullopt && Z == std::nullopt && E == std::nullopt && F == std::nullopt)
+    {
+        throw std::runtime_error(fmt::format("Unable to parse lino: {}", index));
+    }
+}
+
+G280::G280(size_t index, std::string line)
+    : Entry{ index, std::move(line) }
+{
+    const auto& matches = get();
+    if (const auto& value = matches.get<"S">())
+    {
+        S = utils::StringViewToDouble(value.to_view());
+    }
+    else
+    {
+        throw std::runtime_error(fmt::format("Unable to parse lino: {}", index));
+    }
+}
+
+G92::G92(size_t index, std::string line)
+    : Entry{ index, std::move(line) }
+{
+    const auto& matches = get();
+    // clang-format off
+    if (const auto& value = matches.get<"X">()) { X = utils::StringViewToDouble(value.to_view()); }
+    if (const auto& value = matches.get<"Y">()) { Y = utils::StringViewToDouble(value.to_view()); }
+    if (const auto& value = matches.get<"Z">()) { Z = utils::StringViewToDouble(value.to_view()); }
+    if (const auto& value = matches.get<"E">()) { E = utils::StringViewToDouble(value.to_view()); }
+    // clang-format on
+    if (X == std::nullopt && Y == std::nullopt && Z == std::nullopt && E == std::nullopt)
+    {
+        throw std::runtime_error(fmt::format("Unable to parse lino: {}", index));
+    }
+}
+
+InitialTemperatureBuildPlate::InitialTemperatureBuildPlate(size_t index, std::string line)
+    : Entry{ index, std::move(line) }
+{
+    const auto& matches = get();
+    if (const auto& value = matches.get<"S">())
+    {
+        S = utils::StringViewToDouble(value.to_view());
+    }
+    else
+    {
+        throw std::runtime_error(fmt::format("Unable to parse lino: {}", index));
+    }
+}
+
+InitialTemperatureExtruder::InitialTemperatureExtruder(size_t index, std::string line)
+    : Entry{ index, std::move(line) }
+{
+    const auto& matches = get();
+    // clang-format off
+    if (const auto& value = matches.get<"T">()) { T = utils::StringViewToDouble(value.to_view()); }
+    if (const auto& value = matches.get<"S">()) { S = utils::StringViewToDouble(value.to_view()); }
+    // clang-format on
+    if (T == std::nullopt && S == std::nullopt)
+    {
+        throw std::runtime_error(fmt::format("Unable to parse lino: {}", index));
+    }
+}
+
+Layer::Layer(size_t index, std::string line)
+    : Entry{ index, std::move(line) }
+{
+    const auto& matches = get();
+    if (const auto& value = matches.get<"L">())
+    {
+        L = utils::StringViewToDouble(value.to_view());
+    }
+    else
+    {
+        throw std::runtime_error(fmt::format("Unable to parse lino: {}", index));
+    }
+}
 
-void G0::operator()()
+M104::M104(size_t index, std::string line)
+    : Entry{ index, std::move(line) }
 {
-    if (auto x = get().get<"X">())
+    const auto& matches = get();
+    // clang-format off
+    if (const auto& value = matches.get<"S">()) { S = utils::StringViewToDouble(value.to_view()); }
+    if (const auto& value = matches.get<"T">()) { T = utils::StringViewToDouble(value.to_view()); }
+    // clang-format on
+    if (S == std::nullopt && T == std::nullopt)
+    {
+        throw std::runtime_error(fmt::format("Unable to parse lino: {}", index));
+    }
+}
+
+M106::M106(size_t index, std::string line)
+    : Entry{ index, std::move(line) }
+{
+    const auto& matches = get();
+    if (const auto& value = matches.get<"S">())
+    {
+        S = utils::StringViewToDouble(value.to_view());
+    }
+    else
+    {
+        throw std::runtime_error(fmt::format("Unable to parse lino: {}", index));
+    }
+}
+
+M109::M109(size_t index, std::string line)
+    : Entry{ index, std::move(line) }
+{
+    const auto& matches = get();
+    // clang-format off
+    if (const auto& value = matches.get<"S">()) { S = utils::StringViewToDouble(value.to_view()); }
+    if (const auto& value = matches.get<"R">()) { R = utils::StringViewToDouble(value.to_view()); }
+    if (const auto& value = matches.get<"T">()) { T = utils::StringViewToDouble(value.to_view()); }
+    // clang-format on
+    if (S == std::nullopt && R == std::nullopt && T == std::nullopt)
+    {
+        throw std::runtime_error(fmt::format("Unable to parse lino: {}", index));
+    }
+}
+
+M140::M140(size_t index, std::string line)
+    : Entry{ index, std::move(line) }
+{
+    const auto& matches = get();
+    if (const auto& value = matches.get<"S">())
+    {
+        S = utils::StringViewToDouble(value.to_view());
+    }
+    else
     {
-        spdlog::debug("x: {}", x);
+        throw std::runtime_error(fmt::format("Unable to parse lino: {}", index));
     }
-    spdlog::info("lino: {} -> {}", index, line);
 }
 
-void G1::operator()()
+M190::M190(size_t index, std::string line)
+    : Entry{ index, std::move(line) }
 {
-    if (auto x = get().get<"Y">())
+    const auto& matches = get();
+    // clang-format off
+    if (const auto& value = matches.get<"S">()) { S = utils::StringViewToDouble(value.to_view()); }
+    if (const auto& value = matches.get<"R">()) { R = utils::StringViewToDouble(value.to_view()); }
+    // clang-format on
+    if (S == std::nullopt && R == std::nullopt)
+    {
+        throw std::runtime_error(fmt::format("Unable to parse lino: {}", index));
+    }
+}
+
+M204::M204(size_t index, std::string line)
+    : Entry{ index, std::move(line) }
+{
+    const auto& matches = get();
+    // clang-format off
+    if (const auto& value = matches.get<"P">()) { P = utils::StringViewToDouble(value.to_view()); }
+    if (const auto& value = matches.get<"T">()) { T = utils::StringViewToDouble(value.to_view()); }
+    if (const auto& value = matches.get<"S">()) { S = utils::StringViewToDouble(value.to_view()); }
+    // clang-format on
+    if (P == std::nullopt && T == std::nullopt && S == std::nullopt)
+    {
+        throw std::runtime_error(fmt::format("Unable to parse lino: {}", index));
+    }
+}
+
+M205::M205(size_t index, std::string line)
+    : Entry{ index, std::move(line) }
+{
+    const auto& matches = get();
+    // clang-format off
+    if (const auto& value = matches.get<"X">()) { X = utils::StringViewToDouble(value.to_view()); }
+    if (const auto& value = matches.get<"Y">()) { Y = utils::StringViewToDouble(value.to_view()); }
+    if (const auto& value = matches.get<"Z">()) { Z = utils::StringViewToDouble(value.to_view()); }
+    if (const auto& value = matches.get<"E">()) { E = utils::StringViewToDouble(value.to_view()); }
+    // clang-format on
+    if (X == std::nullopt && Y == std::nullopt && Z == std::nullopt && E == std::nullopt)
+    {
+        throw std::runtime_error(fmt::format("Unable to parse lino: {}", index));
+    }
+}
+
+Mesh::Mesh(size_t index, std::string line)
+    : Entry{ index, std::move(line) }
+{
+    const auto& matches = get();
+    if (const auto& value = matches.get<"M">())
+    {
+        M = value.to_view();
+    }
+    else
+    {
+        throw std::runtime_error(fmt::format("Unable to parse lino: {}", index));
+    }
+}
+
+T::T(size_t index, std::string line)
+    : Entry{ index, std::move(line) }
+{
+    const auto& matches = get();
+    if (const auto& value = matches.get<"S">())
+    {
+        S = utils::StringViewToDouble(value.to_view());
+    }
+    else
     {
-        spdlog::debug("Y: {}", x);
+        throw std::runtime_error(fmt::format("Unable to parse lino: {}", index));
     }
-    spdlog::info("lino: {} -> {}", index, line);
 }
 
 } // namespace dulcificum::gcode::ast
\ No newline at end of file
diff --git a/src/proto_path/translate.cpp b/src/proto_path/translate.cpp
index f20130e..ee59a30 100644
--- a/src/proto_path/translate.cpp
+++ b/src/proto_path/translate.cpp
@@ -1,14 +1,33 @@
 #include "dulcificum/proto_path/translate.h"
 
+#include "dulcificum/gcode/ast/ast.h"
+#include "dulcificum/proto_path/ast/ast.h"
+
 #include <spdlog/spdlog.h>
 
+#include <variant>
+
 namespace dulcificum::proto_path
 {
 
-ast::ast_t translate(gcode::ast::ast_t gcode)
+proto_path::ast::ast_t translate(gcode::ast::ast_t gcode)
 {
     spdlog::info("Translating GCode to Proto Path");
-    ast::ast_t ast;
+    proto_path::ast::ast_t ast;
+
+    for (auto& node : gcode)
+    {
+        std::visit(
+            [](auto& n)
+            {
+                auto args = n();
+                if (args.contains("X"))
+                {
+                    spdlog::info("X: {}", std::get<double>(args["X"]));
+                }
+            },
+            node);
+    }
 
     return ast;
 }
diff --git a/src/utils/svtod.cpp b/src/utils/svtod.cpp
new file mode 100644
index 0000000..a249ca9
--- /dev/null
+++ b/src/utils/svtod.cpp
@@ -0,0 +1,13 @@
+#include "dulcificum/utils/svtod.h"
+
+#include <charconv>
+
+namespace dulcificum::utils
+{
+double StringViewToDouble(std::string_view sv)
+{
+    double value = 0.0;
+    std::from_chars(sv.data(), sv.data() + sv.size(), value);
+    return value;
+}
+} // namespace dulcificum::utils
\ No newline at end of file