diff --git a/c_src/lazy_html.cpp b/c_src/lazy_html.cpp
index a9dc1a0..b21731a 100644
--- a/c_src/lazy_html.cpp
+++ b/c_src/lazy_html.cpp
@@ -821,6 +821,157 @@ std::vector<fine::Term> tag(ErlNifEnv *env, ExLazyHTML ex_lazy_html) {
 
 FINE_NIF(tag, 0);
 
+ExLazyHTML replace(ErlNifEnv *env, ExLazyHTML ex_lazy_html,
+                   ErlNifBinary css_selector, ExLazyHTML ex_new_content) {
+  // Parse the CSS selector
+  auto parser = lxb_css_parser_create();
+  auto status = lxb_css_parser_init(parser, NULL);
+  if (status != LXB_STATUS_OK) {
+    throw std::runtime_error("failed to create css parser");
+  }
+  auto parser_guard =
+      ScopeGuard([&]() { lxb_css_parser_destroy(parser, true); });
+
+  auto css_selector_list = parse_css_selector(parser, css_selector);
+
+  // Find matching nodes
+  auto matching_nodes = std::vector<lxb_dom_node_t *>();
+  
+  for (auto node : ex_lazy_html.resource->nodes) {
+    auto selectors = lxb_selectors_create();
+    auto status = lxb_selectors_init(selectors);
+    if (status != LXB_STATUS_OK) {
+      throw std::runtime_error("failed to create selectors");
+    }
+    auto selectors_guard =
+        ScopeGuard([&]() { lxb_selectors_destroy(selectors, true); });
+
+    std::vector<lxb_dom_node_t *> nodes_from_this_root;
+    status = lxb_selectors_find(
+        selectors, node, css_selector_list,
+        [](lxb_dom_node_t *node, lxb_css_selector_specificity_t spec,
+           void *ctx) -> lxb_status_t {
+          auto nodes =
+              reinterpret_cast<std::vector<lxb_dom_node_t *> *>(ctx);
+          nodes->push_back(node);
+          return LXB_STATUS_OK;
+        },
+        &nodes_from_this_root);
+    if (status != LXB_STATUS_OK) {
+      throw std::runtime_error("failed to run find");
+    }
+    
+    matching_nodes.insert(matching_nodes.end(), nodes_from_this_root.begin(),
+                         nodes_from_this_root.end());
+  }
+
+  // Check that exactly one node matches
+  if (matching_nodes.size() == 0) {
+    throw std::invalid_argument("no elements found matching selector");
+  }
+  if (matching_nodes.size() > 1) {
+    throw std::invalid_argument("expected exactly 1 element matching selector, but found " + 
+                               std::to_string(matching_nodes.size()));
+  }
+
+  auto target_node = matching_nodes[0];
+  auto parent_node = lxb_dom_node_parent(target_node);
+  
+  if (parent_node == NULL) {
+    throw std::runtime_error("cannot replace root node");
+  }
+
+  // Insert all new content nodes before the target node
+  for (auto new_node : ex_new_content.resource->nodes) {
+    // Clone the node to avoid ownership issues
+    auto cloned_node = lxb_dom_node_clone(new_node, true);
+    if (cloned_node == NULL) {
+      throw std::runtime_error("failed to clone new content node");
+    }
+    lxb_dom_node_insert_before(target_node, cloned_node);
+  }
+
+  // Remove the target node
+  lxb_dom_node_remove(target_node);
+
+  // Return the original lazy_html (which has been modified in place)
+  return ex_lazy_html;
+}
+
+FINE_NIF(replace, ERL_NIF_DIRTY_JOB_CPU_BOUND);
+
+ExLazyHTML append_child(ErlNifEnv *env, ExLazyHTML ex_lazy_html,
+                        ErlNifBinary css_selector, ExLazyHTML ex_child_content) {
+  // Parse the CSS selector
+  auto parser = lxb_css_parser_create();
+  auto status = lxb_css_parser_init(parser, NULL);
+  if (status != LXB_STATUS_OK) {
+    throw std::runtime_error("failed to create css parser");
+  }
+  auto parser_guard =
+      ScopeGuard([&]() { lxb_css_parser_destroy(parser, true); });
+
+  auto css_selector_list = parse_css_selector(parser, css_selector);
+
+  // Find matching nodes
+  auto selectors = lxb_selectors_create();
+  status = lxb_selectors_init(selectors);
+  if (status != LXB_STATUS_OK) {
+    throw std::runtime_error("failed to create selectors");
+  }
+  auto selectors_guard =
+      ScopeGuard([&]() { lxb_selectors_destroy(selectors, true); });
+
+  // Set selector options to match root nodes and get unique elements
+  lxb_selectors_opt_set(selectors, static_cast<lxb_selectors_opt_t>(
+                                       LXB_SELECTORS_OPT_MATCH_FIRST |
+                                       LXB_SELECTORS_OPT_MATCH_ROOT));
+
+  auto matching_nodes = std::vector<lxb_dom_node_t *>();
+  
+  for (auto node : ex_lazy_html.resource->nodes) {
+    status = lxb_selectors_find(
+        selectors, node, css_selector_list,
+        [](lxb_dom_node_t *node, lxb_css_selector_specificity_t spec,
+           void *ctx) -> lxb_status_t {
+          auto nodes =
+              reinterpret_cast<std::vector<lxb_dom_node_t *> *>(ctx);
+          nodes->push_back(node);
+          return LXB_STATUS_OK;
+        },
+        &matching_nodes);
+    if (status != LXB_STATUS_OK) {
+      throw std::runtime_error("failed to run find");
+    }
+  }
+
+  // Check that exactly one node matches
+  if (matching_nodes.size() == 0) {
+    throw std::invalid_argument("no elements found matching selector");
+  }
+  if (matching_nodes.size() > 1) {
+    throw std::invalid_argument("expected exactly 1 element matching selector, but found " + 
+                               std::to_string(matching_nodes.size()));
+  }
+
+  auto parent_node = matching_nodes[0];
+
+  // Append all child content nodes to the parent node
+  for (auto child_node : ex_child_content.resource->nodes) {
+    // Clone the node to avoid ownership issues
+    auto cloned_node = lxb_dom_node_clone(child_node, true);
+    if (cloned_node == NULL) {
+      throw std::runtime_error("failed to clone child content node");
+    }
+    lxb_dom_node_insert_child(parent_node, cloned_node);
+  }
+
+  // Return the original lazy_html (which has been modified in place)
+  return ex_lazy_html;
+}
+
+FINE_NIF(append_child, ERL_NIF_DIRTY_JOB_CPU_BOUND);
+
 } // namespace lazy_html
 
 FINE_INIT("Elixir.LazyHTML.NIF");
diff --git a/lib/lazy_html.ex b/lib/lazy_html.ex
index d814697..ea23778 100644
--- a/lib/lazy_html.ex
+++ b/lib/lazy_html.ex
@@ -481,6 +481,71 @@ defmodule LazyHTML do
     LazyHTML.NIF.tag(lazy_html)
   end
 
+  @doc ~S'''
+  Replaces the element matching the given CSS selector with new content.
+
+  The function expects exactly one element to match the selector. If no
+  element or more than one element matches, it raises an ArgumentError.
+
+  ## Examples
+
+      iex> lazy_html = LazyHTML.from_fragment(~S|<div id="main"><span>Old content</span></div>|)
+      iex> new_content = LazyHTML.from_fragment(~S|<p>New content</p>|)
+      iex> LazyHTML.replace(lazy_html, "#main span", new_content)
+      #LazyHTML<
+        1 node
+        #1
+        <div id="main"><p>New content</p></div>
+      >
+
+      iex> lazy_html = LazyHTML.from_fragment(~S|<ul><li>Item 1</li><li id="target">Item 2</li><li>Item 3</li></ul>|)
+      iex> new_content = LazyHTML.from_fragment(~S|<li class="replaced">Replaced item</li>|)
+      iex> LazyHTML.replace(lazy_html, "#target", new_content)
+      #LazyHTML<
+        1 node
+        #1
+        <ul><li>Item 1</li><li class="replaced">Replaced item</li><li>Item 3</li></ul>
+      >
+
+  '''
+  @spec replace(t(), String.t(), t()) :: t()
+  def replace(%LazyHTML{} = lazy_html, selector, %LazyHTML{} = new_content) when is_binary(selector) do
+    LazyHTML.NIF.replace(lazy_html, selector, new_content)
+  end
+
+  @doc ~S'''
+  Appends child content to the element matching the given CSS selector.
+
+  The function expects exactly one element to match the selector. If no
+  element or more than one element matches, it raises an ArgumentError.
+  The child content is appended as the last child(ren) of the matched element.
+
+  ## Examples
+
+      iex> lazy_html = LazyHTML.from_fragment(~S|<div id="container"><p>Existing content</p></div>|)
+      iex> child_content = LazyHTML.from_fragment(~S|<span>New child</span>|)
+      iex> LazyHTML.appendChild(lazy_html, "#container", child_content)
+      #LazyHTML<
+        1 node
+        #1
+        <div id="container"><p>Existing content</p><span>New child</span></div>
+      >
+
+      iex> lazy_html = LazyHTML.from_fragment(~S|<ul id="list"><li>Item 1</li></ul>|)
+      iex> child_content = LazyHTML.from_fragment(~S|<li>Item 2</li><li>Item 3</li>|)
+      iex> LazyHTML.appendChild(lazy_html, "#list", child_content)
+      #LazyHTML<
+        1 node
+        #1
+        <ul id="list"><li>Item 1</li><li>Item 2</li><li>Item 3</li></ul>
+      >
+
+  '''
+  @spec appendChild(t(), String.t(), t()) :: t()
+  def appendChild(%LazyHTML{} = lazy_html, selector, %LazyHTML{} = child_content) when is_binary(selector) do
+    LazyHTML.NIF.append_child(lazy_html, selector, child_content)
+  end
+
   @doc ~S"""
   Escapes the given string to make a valid HTML text.
 
diff --git a/lib/lazy_html/nif.ex b/lib/lazy_html/nif.ex
index e7098ac..efcccdf 100644
--- a/lib/lazy_html/nif.ex
+++ b/lib/lazy_html/nif.ex
@@ -27,6 +27,8 @@ defmodule LazyHTML.NIF do
   def tag(_lazy_html), do: err!()
   def nodes(_lazy_html), do: err!()
   def num_nodes(_lazy_html), do: err!()
+  def replace(_lazy_html, _css_selector, _new_content), do: err!()
+  def append_child(_lazy_html, _css_selector, _child_content), do: err!()
 
   defp err!(), do: :erlang.nif_error(:not_loaded)
 end
diff --git a/test/lazy_html_test.exs b/test/lazy_html_test.exs
index 422a36e..20c475a 100644
--- a/test/lazy_html_test.exs
+++ b/test/lazy_html_test.exs
@@ -250,6 +250,154 @@ defmodule LazyHTMLTest do
     end
   end
 
+  describe "replace/3" do
+    test "replaces a single element with new content" do
+      lazy_html = LazyHTML.from_fragment(~S|<div id="main"><span>Old content</span></div>|)
+      new_content = LazyHTML.from_fragment(~S|<p>New content</p>|)
+      
+      result = LazyHTML.replace(lazy_html, "#main span", new_content)
+      
+      assert LazyHTML.to_html(result) == ~S|<div id="main"><p>New content</p></div>|
+    end
+
+    test "replaces element in a list" do
+      lazy_html = LazyHTML.from_fragment(~S|<ul><li>Item 1</li><li id="target">Item 2</li><li>Item 3</li></ul>|)
+      new_content = LazyHTML.from_fragment(~S|<li class="replaced">Replaced item</li>|)
+      
+      result = LazyHTML.replace(lazy_html, "#target", new_content)
+      
+      assert LazyHTML.to_html(result) == ~S|<ul><li>Item 1</li><li class="replaced">Replaced item</li><li>Item 3</li></ul>|
+    end
+
+    test "replaces with multiple nodes" do
+      lazy_html = LazyHTML.from_fragment(~S|<div><p id="old">Old paragraph</p></div>|)
+      new_content = LazyHTML.from_fragment(~S|<h1>Title</h1><p>New paragraph</p>|)
+      
+      result = LazyHTML.replace(lazy_html, "#old", new_content)
+      
+      assert LazyHTML.to_html(result) == ~S|<div><h1>Title</h1><p>New paragraph</p></div>|
+    end
+
+    test "raises when no elements match" do
+      lazy_html = LazyHTML.from_fragment(~S|<div><span>Content</span></div>|)
+      new_content = LazyHTML.from_fragment(~S|<p>New content</p>|)
+      
+      assert_raise ArgumentError, "no elements found matching selector", fn ->
+        LazyHTML.replace(lazy_html, "#nonexistent", new_content)
+      end
+    end
+
+    test "raises when multiple elements match" do
+      lazy_html = LazyHTML.from_fragment(~S|<div><span>First</span><span>Second</span></div>|)
+      new_content = LazyHTML.from_fragment(~S|<p>New content</p>|)
+      
+      assert_raise ArgumentError, ~r/expected exactly 1 element matching selector.*but found 2/, fn ->
+        LazyHTML.replace(lazy_html, "span", new_content)
+      end
+    end
+
+    test "works with complex selectors" do
+      lazy_html = LazyHTML.from_fragment(~S|<div class="container"><div class="item active">Active item</div><div class="item">Inactive item</div></div>|)
+      new_content = LazyHTML.from_fragment(~S|<div class="item updated">Updated item</div>|)
+      
+      result = LazyHTML.replace(lazy_html, ".item.active", new_content)
+      
+      assert LazyHTML.to_html(result) == ~S|<div class="container"><div class="item updated">Updated item</div><div class="item">Inactive item</div></div>|
+    end
+
+    test "preserves document structure when replacing nested elements" do
+      lazy_html = LazyHTML.from_fragment(~S|<article><header><h1 id="title">Old Title</h1></header><main>Content</main></article>|)
+      new_content = LazyHTML.from_fragment(~S|<h1 id="title" class="new">New Title</h1>|)
+      
+      result = LazyHTML.replace(lazy_html, "#title", new_content)
+      
+      assert LazyHTML.to_html(result) == ~S|<article><header><h1 id="title" class="new">New Title</h1></header><main>Content</main></article>|
+    end
+  end
+
+  describe "appendChild/3" do
+    test "appends a single child to container" do
+      lazy_html = LazyHTML.from_fragment(~S|<div id="container"><p>Existing content</p></div>|)
+      child_content = LazyHTML.from_fragment(~S|<span>New child</span>|)
+      
+      result = LazyHTML.appendChild(lazy_html, "#container", child_content)
+      
+      assert LazyHTML.to_html(result) == ~S|<div id="container"><p>Existing content</p><span>New child</span></div>|
+    end
+
+    test "appends multiple children to list" do
+      lazy_html = LazyHTML.from_fragment(~S|<ul id="list"><li>Item 1</li></ul>|)
+      child_content = LazyHTML.from_fragment(~S|<li>Item 2</li><li>Item 3</li>|)
+      
+      result = LazyHTML.appendChild(lazy_html, "#list", child_content)
+      
+      assert LazyHTML.to_html(result) == ~S|<ul id="list"><li>Item 1</li><li>Item 2</li><li>Item 3</li></ul>|
+    end
+
+    test "appends to empty element" do
+      lazy_html = LazyHTML.from_fragment(~S|<div id="empty"></div>|)
+      child_content = LazyHTML.from_fragment(~S|<p>First content</p>|)
+      
+      result = LazyHTML.appendChild(lazy_html, "#empty", child_content)
+      
+      assert LazyHTML.to_html(result) == ~S|<div id="empty"><p>First content</p></div>|
+    end
+
+    test "appends mixed content types" do
+      lazy_html = LazyHTML.from_fragment(~S|<section id="content"><h1>Title</h1></section>|)
+      child_content = LazyHTML.from_fragment(~S|<p>Paragraph</p><ul><li>List item</li></ul>|)
+      
+      result = LazyHTML.appendChild(lazy_html, "#content", child_content)
+      
+      assert LazyHTML.to_html(result) == ~S|<section id="content"><h1>Title</h1><p>Paragraph</p><ul><li>List item</li></ul></section>|
+    end
+
+    test "preserves existing children order" do
+      lazy_html = LazyHTML.from_fragment(~S|<div class="parent"><span>First</span><span>Second</span></div>|)
+      child_content = LazyHTML.from_fragment(~S|<span>Third</span>|)
+      
+      result = LazyHTML.appendChild(lazy_html, ".parent", child_content)
+      
+      assert LazyHTML.to_html(result) == ~S|<div class="parent"><span>First</span><span>Second</span><span>Third</span></div>|
+    end
+
+    test "raises when no elements match" do
+      lazy_html = LazyHTML.from_fragment(~S|<div><span>Content</span></div>|)
+      child_content = LazyHTML.from_fragment(~S|<p>Child content</p>|)
+      
+      assert_raise ArgumentError, "no elements found matching selector", fn ->
+        LazyHTML.appendChild(lazy_html, "#nonexistent", child_content)
+      end
+    end
+
+    test "raises when multiple elements match" do
+      lazy_html = LazyHTML.from_fragment(~S|<div><div class="target">First</div><div class="target">Second</div></div>|)
+      child_content = LazyHTML.from_fragment(~S|<p>Child content</p>|)
+      
+      assert_raise ArgumentError, ~r/expected exactly 1 element matching selector.*but found 2/, fn ->
+        LazyHTML.appendChild(lazy_html, ".target", child_content)
+      end
+    end
+
+    test "works with complex selectors" do
+      lazy_html = LazyHTML.from_fragment(~S|<article><div class="content main"><p>Existing</p></div><div class="content">Other</div></article>|)
+      child_content = LazyHTML.from_fragment(~S|<p>Appended to main</p>|)
+      
+      result = LazyHTML.appendChild(lazy_html, ".content.main", child_content)
+      
+      assert LazyHTML.to_html(result) == ~S|<article><div class="content main"><p>Existing</p><p>Appended to main</p></div><div class="content">Other</div></article>|
+    end
+
+    test "works with nested elements" do
+      lazy_html = LazyHTML.from_fragment(~S|<div><article><section id="target"><h2>Section</h2></section></article></div>|)
+      child_content = LazyHTML.from_fragment(~S|<p>New paragraph</p>|)
+      
+      result = LazyHTML.appendChild(lazy_html, "#target", child_content)
+      
+      assert LazyHTML.to_html(result) == ~S|<div><article><section id="target"><h2>Section</h2><p>New paragraph</p></section></article></div>|
+    end
+  end
+
   describe "query_by_id/2" do
     test "raises when an empty id is given" do
       assert_raise ArgumentError, ~r/id cannot be empty/, fn ->