diff --git a/src/forest.gleam b/src/forest.gleam
index 2a17e04..a387edb 100644
--- a/src/forest.gleam
+++ b/src/forest.gleam
@@ -9,9 +9,7 @@ import json_serde
 import query
 import simplifile
 import tree
-import tree_events.{
-  type TreeEvents, GetEvent, RecursiveGetEvent, SetEvent, Shutdown, Snapshot,
-}
+import tree_events.{type TreeEvents, GetEvent, SetEvent, Shutdown, Snapshot}
 
 pub type Message {
   Message
@@ -78,15 +76,7 @@ pub fn load(snapshots_path, names) {
 fn handle_message(event: TreeEvents, tree) {
   case event {
     GetEvent(path, client) -> {
-      let res = query.get(tree, path, False)
-      actor.send(
-        client,
-        res |> result.map(fn(tree) { tree |> json_serde.serialize }),
-      )
-      actor.continue(tree)
-    }
-    RecursiveGetEvent(path, client) -> {
-      let res = query.get(tree, path, False)
+      let res = query.get(tree, path)
       actor.send(
         client,
         res |> result.map(fn(tree) { tree |> json_serde.serialize }),
diff --git a/src/query.gleam b/src/query.gleam
index f4d709e..5af510b 100644
--- a/src/query.gleam
+++ b/src/query.gleam
@@ -10,7 +10,7 @@ import tree_events
 /// 
 /// Query formats:
 /// 
-/// - get | rget (path)
+/// - get (path)
 /// - set (path) (data)
 pub fn parse(query: String) {
   let args = query |> string.split(" ")
@@ -23,14 +23,6 @@ pub fn parse(query: String) {
           |> Ok
       }
     }
-    ["rget", path] -> {
-      case path |> parse_path {
-        Error(_) -> Error(QueryError("Wrong query format."))
-        Ok(#(head, tail)) ->
-          #(head, fn(actor) { tree_events.RecursiveGetEvent(tail, actor) })
-          |> Ok
-      }
-    }
     ["set", path, data] -> {
       case path |> parse_path {
         Error(_) -> Error(QueryError("Wrong query format."))
@@ -50,11 +42,8 @@ pub fn parse(query: String) {
   }
 }
 
-pub fn get(tree, path, recursive) -> Result(tree.Tree, QueryError) {
-  let res = case recursive {
-    False -> tree.get(tree, path)
-    _ -> tree.rget(tree, path)
-  }
+pub fn get(tree, path) -> Result(tree.Tree, QueryError) {
+  let res = tree.get(tree, path)
   case res {
     Error(_) -> Error(QueryError("There is no such node."))
     Ok(tree) -> Ok(tree)
diff --git a/src/tree.gleam b/src/tree.gleam
index 89556f2..6d0775d 100644
--- a/src/tree.gleam
+++ b/src/tree.gleam
@@ -18,10 +18,6 @@ pub fn new() {
   Root(dict.new())
 }
 
-/// Traverses the tree along the given path.
-/// 
-/// If the last found node is a Leaf, returns it.
-/// Else returns Nil
 pub fn get(tree, path) {
   let res = get_step(tree, path)
   case res {
@@ -30,15 +26,6 @@ pub fn get(tree, path) {
   }
 }
 
-/// Recursive Get: returns whole requsted subtree
-pub fn rget(tree, path) {
-  let res = get_step(tree, path)
-  case res {
-    Error(_) -> Error(Nil)
-    Ok(_) as res -> res
-  }
-}
-
 fn get_step(tree: Tree, path: List(String)) -> Result(Tree, Nil) {
   case tree, path {
     Root(_) as rt, [] -> Ok(rt)
diff --git a/src/tree_events.gleam b/src/tree_events.gleam
index 823204d..065e9ce 100644
--- a/src/tree_events.gleam
+++ b/src/tree_events.gleam
@@ -5,11 +5,6 @@ import tree
 pub type TreeEvents {
   GetEvent(path: List(String), reply_with: Subject(Result(String, QueryError)))
 
-  RecursiveGetEvent(
-    path: List(String),
-    reply_with: Subject(Result(String, QueryError)),
-  )
-
   SetEvent(
     path: List(String),
     data: tree.LeafData,
diff --git a/src/treevault.gleam b/src/treevault.gleam
index 97346f3..3e079d5 100644
--- a/src/treevault.gleam
+++ b/src/treevault.gleam
@@ -105,7 +105,6 @@ fn read_next(forest) {
           "help" |> io.println
           "exit" |> io.println
           "get <path>" |> io.println
-          "rget <path>" |> io.println
           "set <path> <data>" |> io.println
           "trees" |> io.println
 
diff --git a/test/raw_benchmark.gleam b/test/raw_benchmark.gleam
index 92dab5d..bf95760 100644
--- a/test/raw_benchmark.gleam
+++ b/test/raw_benchmark.gleam
@@ -50,8 +50,7 @@ fn get_100k(tree, i) {
     100_000 -> Nil
     _ -> {
       let rint = int.random(1_000_000)
-      let assert Ok(_) =
-        tree |> query.get([".", rint |> int.to_string()], False)
+      let assert Ok(_) = tree |> query.get([".", rint |> int.to_string()])
       get_100k(tree, i + 1)
     }
   }
@@ -98,7 +97,7 @@ fn setup_nodes_tasks(tree, paths) {
 fn get_nodes(tree, paths) {
   paths
   |> list.fold(tree, fn(tree, path) {
-    let _ = tree |> query.get(path, True)
+    let _ = tree |> query.get(path)
     tree
   })
 }
diff --git a/test/server_test.gleam b/test/server_test.gleam
index dd1ef80..36402e9 100644
--- a/test/server_test.gleam
+++ b/test/server_test.gleam
@@ -31,7 +31,7 @@ pub fn server_test() {
 
   let assert Ok(Nil) = mug.send(socket, <<"set root.b \"foo\"":utf8>>)
   let assert Ok(_) = mug.receive(socket, timeout_milliseconds: 100)
-  let assert Ok(Nil) = mug.send(socket, <<"rget root":utf8>>)
+  let assert Ok(Nil) = mug.send(socket, <<"get root":utf8>>)
   let assert Ok(packet) = mug.receive(socket, timeout_milliseconds: 100)
 
   packet |> should.equal(<<"{\"a\":2,\"b\":\"foo\"}":utf8>>)
diff --git a/test/treevault_test.gleam b/test/treevault_test.gleam
index 53153a0..6966f31 100644
--- a/test/treevault_test.gleam
+++ b/test/treevault_test.gleam
@@ -24,15 +24,15 @@ pub fn kv_test() {
   let assert Ok(tree) = query.set(tree, ["d"], tree.Bool(False))
   let assert Ok(tree) = query.set(tree, ["e"], tree.Null)
 
-  query.get(tree, ["a"], False)
+  query.get(tree, ["a"])
   |> should.equal(tree.Leaf(tree.String("foo")) |> Ok())
-  query.get(tree, ["b"], False)
+  query.get(tree, ["b"])
   |> should.equal(tree.Leaf(tree.Int(42)) |> Ok())
-  query.get(tree, ["c"], False)
+  query.get(tree, ["c"])
   |> should.equal(tree.Leaf(tree.Float(12.34)) |> Ok())
-  query.get(tree, ["d"], False)
+  query.get(tree, ["d"])
   |> should.equal(tree.Leaf(tree.Bool(False)) |> Ok())
-  query.get(tree, ["e"], False)
+  query.get(tree, ["e"])
   |> should.equal(tree.Leaf(tree.Null) |> Ok())
 }
 
@@ -45,15 +45,15 @@ pub fn tree_test() {
   let assert Ok(tree) = query.set(tree, ["a2", "b3"], tree.Int(42))
   let assert Ok(tree) = query.set(tree, ["a2", "b3"], tree.Int(43))
 
-  query.get(tree, ["a", "b"], False)
+  query.get(tree, ["a", "b"])
   |> should.equal(tree.Leaf(tree.String("new foo")) |> Ok())
 
-  query.get(tree, ["a", "b2"], True)
+  query.get(tree, ["a", "b2"])
   |> should.equal(
     tree.Node(dict.new() |> dict.insert("c", tree.Leaf(tree.String("bar"))))
     |> Ok(),
   )
-  query.get(tree, ["a2", "b3"], False)
+  query.get(tree, ["a2", "b3"])
   |> should.equal(tree.Leaf(tree.Int(43)) |> Ok())
 }