diff --git a/examples/reference-wrappers/src/input.cc b/examples/reference-wrappers/src/input.cc
new file mode 100644
index 0000000..afb7eb2
--- /dev/null
+++ b/examples/reference-wrappers/src/input.cc
@@ -0,0 +1,11 @@
+// Copyright 2022 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#include "input.h"
+
+Goat the_goat;
diff --git a/examples/reference-wrappers/src/input.h b/examples/reference-wrappers/src/input.h
new file mode 100644
index 0000000..5e3c6e9
--- /dev/null
+++ b/examples/reference-wrappers/src/input.h
@@ -0,0 +1,42 @@
+// Copyright 2022 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#pragma once
+
+#include <cstdint>
+#include <sstream>
+#include <stdint.h>
+#include <string>
+
+class Goat {
+public:
+    Goat() : horns(0) {}
+    void add_a_horn();
+    std::string describe() const;
+private:
+    uint32_t horns;
+};
+
+
+inline void Goat::add_a_horn() { horns++; }
+inline std::string Goat::describe() const {
+    std::ostringstream oss;
+    std::string plural = horns == 1 ? "" : "s";
+    oss << "This goat has " << horns << " horn" << plural << ".";
+    return oss.str();
+}
+
+class Field {
+public:
+    const Goat& get_goat() const {
+        return the_goat;
+    }
+
+private:
+    Goat the_goat;
+};
diff --git a/examples/reference-wrappers/src/main.rs b/examples/reference-wrappers/src/main.rs
new file mode 100644
index 0000000..6bea2ff
--- /dev/null
+++ b/examples/reference-wrappers/src/main.rs
@@ -0,0 +1,67 @@
+// Copyright 2022 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// This example serves to demonstrate the experimental C++
+// reference wrappers. They exist because C++ references are not
+// the same as Rust references: C++ references may alias, whereas
+// Rust references may not.
+//
+// Standard autocxx behavior therefore introduces unsoundness when
+// C++ references are encountered and treated like Rust references.
+// (cxx has this soundness problem for Trivial types; autocxx
+// makes it worse in that the same problem applies even for
+// opaque types, because we make them sized such that we can allocate
+// them on the stack).
+//
+// Reference wrappers solve that problem because internally, they're
+// just pointers. On the other hand, they're awkward to use,
+// especially in the absence of the Rust "arbitrary self types"
+// feature.
+
+use autocxx::prelude::*;
+
+include_cpp! {
+    #include "input.h"
+    // This next line enables C++ reference wrappers
+    safety!(unsafe_references_wrapped)
+    generate!("Goat")
+    generate!("Field")
+}
+
+fn main() {
+    // Create a cxx::UniquePtr as normal for a Field object.
+    let field = ffi::Field::new().within_unique_ptr();
+    // We assume at this point that C++ has had no opportunity
+    // to retain any reference to the Field. That's not strictly
+    // true, due to RVO, but under all reasonable circumstances
+    // Rust currently has exclusive ownership of the Field we've
+    // been given.
+    // Therefore, at this point in the program, it's still
+    // OK to take Rust references to this Field.
+    let _field_rust_ref = field.as_ref();
+    // However, as soon as we want to pass a reference to the field
+    // back to C++, we have to ensure we have no Rust references
+    // in existence. So: we imprison the object in a "CppPin":
+    let field = ffi::cpp_pin_uniqueptr(field);
+    // We can no longer take Rust references to the field...
+    //   let _field_rust_ref = field.as_ref();
+    // However, we can take C++ references. And use such references
+    // to call methods...
+    let another_goat = field.as_cpp_ref().get_goat();
+    // The 'get_goat' method in C++ returns a reference, so this is
+    // another CppRef, not a Rust reference.
+    assert_eq!(
+        another_goat
+            .describe() // returns a UniquePtr<CxxString>, there
+                // are no Rust or C++ references involved at this point.
+            .as_ref()
+            .unwrap()
+            .to_string_lossy(),
+        "This goat has 0 horns."
+    );
+}