diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 25c2d37c..5697cdf0 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -13,3 +13,6 @@ jobs:
     - uses: actions/checkout@v3
     - name: Run tests
       run: cargo test
+
+    - name: Run sync tests
+      run: cargo test --features sync
diff --git a/Cargo.toml b/Cargo.toml
index 29e993dc..ccdc20f3 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -20,4 +20,5 @@ name = "tulisp"
 path = "src/lib.rs"
 
 [features]
+sync = []
 big_functions = []
diff --git a/src/builtin/functions/hash_table.rs b/src/builtin/functions/hash_table.rs
index ba966ed4..10d2d4f1 100644
--- a/src/builtin/functions/hash_table.rs
+++ b/src/builtin/functions/hash_table.rs
@@ -1,5 +1,8 @@
-use crate::{Error, TulispAny, TulispContext, TulispObject, destruct_eval_bind};
-use std::{cell::RefCell, collections::HashMap, rc::Rc};
+use crate::{
+    Error, TulispContext, TulispObject, destruct_eval_bind,
+    object::wrappers::generic::{Shared, SharedMut},
+};
+use std::collections::HashMap;
 
 struct TulispObjectEql(TulispObject);
 
@@ -29,7 +32,7 @@ impl From<TulispObject> for TulispObjectEql {
 }
 
 pub(crate) struct HashTable {
-    inner: RefCell<HashMap<TulispObjectEql, TulispObject>>,
+    inner: SharedMut<HashMap<TulispObjectEql, TulispObject>>,
 }
 
 impl std::fmt::Display for HashTable {
@@ -46,8 +49,8 @@ pub(crate) fn add(ctx: &mut TulispContext) {
             )
             .with_trace(args.clone()));
         }
-        let table: Rc<dyn TulispAny> = Rc::new(HashTable {
-            inner: RefCell::new(HashMap::new()),
+        let table = Shared::new_any(HashTable {
+            inner: SharedMut::new(HashMap::new()),
         });
         Ok(table.into())
     });
diff --git a/src/context.rs b/src/context.rs
index e83c5856..fc1d463c 100644
--- a/src/context.rs
+++ b/src/context.rs
@@ -3,7 +3,7 @@ mod add_function;
 mod rest;
 pub use rest::Rest;
 
-use std::{collections::HashMap, fs, rc::Rc};
+use std::{collections::HashMap, fs};
 
 use crate::{
     TulispObject, TulispValue, builtin,
@@ -11,6 +11,7 @@ use crate::{
     error::Error,
     eval::{DummyEval, eval, eval_and_then, eval_basic, funcall},
     list,
+    object::wrappers::generic::{Shared, TulispFn},
     parse::parse,
 };
 
@@ -86,13 +87,9 @@ impl TulispContext {
     }
 
     #[inline(always)]
-    pub fn add_special_form(
-        &mut self,
-        name: &str,
-        func: impl Fn(&mut TulispContext, &TulispObject) -> Result<TulispObject, Error> + 'static,
-    ) {
+    pub fn add_special_form(&mut self, name: &str, func: impl TulispFn + std::any::Any) {
         self.intern(name)
-            .set_global(TulispValue::Func(Rc::new(func)).into_ref(None))
+            .set_global(TulispValue::Func(Shared::new_tulisp_fn(func)).into_ref(None))
             .unwrap();
     }
 
@@ -125,13 +122,9 @@ impl TulispContext {
     }
 
     #[inline(always)]
-    pub fn add_macro(
-        &mut self,
-        name: &str,
-        func: impl Fn(&mut TulispContext, &TulispObject) -> Result<TulispObject, Error> + 'static,
-    ) {
+    pub fn add_macro(&mut self, name: &str, func: impl TulispFn) {
         self.intern(name)
-            .set_global(TulispValue::Macro(Rc::new(func)).into_ref(None))
+            .set_global(TulispValue::Macro(Shared::new_tulisp_fn(func)).into_ref(None))
             .unwrap();
     }
 
diff --git a/src/context/add_function.rs b/src/context/add_function.rs
index e87cc183..127f7b9c 100644
--- a/src/context/add_function.rs
+++ b/src/context/add_function.rs
@@ -1,3 +1,4 @@
+use crate::object::wrappers::generic::SyncSend;
 use crate::{Error, Rest, TulispContext, TulispObject, destruct_bind, destruct_eval_bind};
 
 pub trait TulispCallable<
@@ -25,7 +26,7 @@ macro_rules! impl_tulisp_callable {
         impl<OutT, FnT, $($arg,)* $($opt,)*>
         TulispCallable<($($arg,)* $($opt,)*) , OutT, false, $args_count, $opts_count, false, true, false> for FnT
         where
-        FnT: Fn($($arg,)* $(Option<$opt>),*) -> OutT + 'static,
+        FnT: Fn($($arg,)* $(Option<$opt>),*) -> OutT + 'static + SyncSend,
         $($arg: TryFrom<TulispObject, Error = Error> + 'static,)*
         $($opt: TryFrom<TulispObject, Error = Error> + 'static,)*
         OutT: Into<TulispObject> + 'static,
@@ -51,7 +52,7 @@ macro_rules! impl_tulisp_callable {
         impl<FnT, $($arg,)* $($opt,)*>
         TulispCallable<($($arg,)* $($opt,)*) , (), false, $args_count, $opts_count, false, false, false> for FnT
         where
-        FnT: Fn($($arg,)* $(Option<$opt>),*) + 'static,
+        FnT: Fn($($arg,)* $(Option<$opt>),*) + 'static + SyncSend,
         $($arg: TryFrom<TulispObject, Error = Error> + 'static,)*
         $($opt: TryFrom<TulispObject, Error = Error> + 'static,)*
         {
@@ -76,7 +77,7 @@ macro_rules! impl_tulisp_callable {
         impl<OutT, FnT, $($arg,)* $($opt,)*>
         TulispCallable<($($arg,)* $($opt,)*) , OutT, true, $args_count, $opts_count, false, true,false> for FnT
         where
-        FnT: Fn(&mut TulispContext, $($arg,)* $(Option<$opt>),*) -> OutT + 'static,
+        FnT: Fn(&mut TulispContext, $($arg,)* $(Option<$opt>),*) -> OutT + 'static + SyncSend,
         $($arg: TryFrom<TulispObject, Error = Error> + 'static,)*
         $($opt: TryFrom<TulispObject, Error = Error> + 'static,)*
         OutT: Into<TulispObject> + 'static,
@@ -102,7 +103,7 @@ macro_rules! impl_tulisp_callable {
         impl<FnT, $($arg,)* $($opt,)*>
         TulispCallable<($($arg,)* $($opt,)*), (), true, $args_count, $opts_count, false, false,false> for FnT
         where
-        FnT: Fn(&mut TulispContext, $($arg,)* $(Option<$opt>),*) + 'static,
+        FnT: Fn(&mut TulispContext, $($arg,)* $(Option<$opt>),*) + 'static + SyncSend,
         $($arg: TryFrom<TulispObject, Error = Error> + 'static,)*
         $($opt: TryFrom<TulispObject, Error = Error> + 'static,)*
         {
@@ -127,7 +128,7 @@ macro_rules! impl_tulisp_callable {
         impl<OutT, FnT, $($arg,)* $($opt,)*>
         TulispCallable<($($arg,)* $($opt,)*) , OutT, false, $args_count, $opts_count, false, true, true> for FnT
         where
-        FnT: Fn($($arg,)* $(Option<$opt>),*) -> Result<OutT, Error> + 'static,
+        FnT: Fn($($arg,)* $(Option<$opt>),*) -> Result<OutT, Error> + 'static + SyncSend,
         $($arg: TryFrom<TulispObject, Error = Error> + 'static,)*
         $($opt: TryFrom<TulispObject, Error = Error> + 'static,)*
         OutT: Into<TulispObject> + 'static,
@@ -153,7 +154,7 @@ macro_rules! impl_tulisp_callable {
         impl<OutT, FnT, $($arg,)* $($opt,)*>
         TulispCallable<($($arg,)* $($opt,)*) , OutT, true, $args_count, $opts_count, false, true, true> for FnT
         where
-        FnT: Fn(&mut TulispContext, $($arg,)* $(Option<$opt>),*) -> Result<OutT, Error> + 'static,
+        FnT: Fn(&mut TulispContext, $($arg,)* $(Option<$opt>),*) -> Result<OutT, Error> + 'static + SyncSend,
         $($arg: TryFrom<TulispObject, Error = Error> + 'static,)*
         $($opt: TryFrom<TulispObject, Error = Error> + 'static,)*
         OutT: Into<TulispObject> + 'static,
@@ -179,7 +180,7 @@ macro_rules! impl_tulisp_callable {
         impl<RestT, OutT, FnT, $($arg,)* $($opt,)*>
         TulispCallable<($($arg,)* $($opt,)* RestT,), OutT, false, $args_count, $opts_count, true, true, false> for FnT
         where
-        FnT: Fn($($arg,)* $(Option<$opt>,)* Rest<RestT>) -> OutT + 'static,
+        FnT: Fn($($arg,)* $(Option<$opt>,)* Rest<RestT>) -> OutT + 'static + SyncSend,
         $($arg: TryFrom<TulispObject, Error = Error> + 'static,)*
         $($opt: TryFrom<TulispObject, Error = Error> + 'static,)*
         RestT: TryFrom<TulispObject, Error = Error> + Into<TulispObject> + 'static,
@@ -216,7 +217,7 @@ macro_rules! impl_tulisp_callable {
         impl<RestT, FnT, $($arg,)* $($opt,)*>
         TulispCallable<($($arg,)* $($opt,)* RestT,), (), false, $args_count, $opts_count, true, false, false> for FnT
         where
-        FnT: Fn($($arg,)* $(Option<$opt>,)* Rest<RestT>) + 'static,
+        FnT: Fn($($arg,)* $(Option<$opt>,)* Rest<RestT>) + 'static + SyncSend,
         $($arg: TryFrom<TulispObject, Error = Error> + 'static,)*
         $($opt: TryFrom<TulispObject, Error = Error> + 'static,)*
         RestT: TryFrom<TulispObject, Error = Error> + Into<TulispObject> + 'static,
@@ -252,7 +253,7 @@ macro_rules! impl_tulisp_callable {
         impl<RestT, OutT, FnT, $($arg,)* $($opt,)*>
         TulispCallable<($($arg,)* $($opt,)* RestT,), OutT, true, $args_count, $opts_count, true, true, false> for FnT
         where
-        FnT: Fn(&mut TulispContext, $($arg,)* $(Option<$opt>,)* Rest<RestT>) -> OutT + 'static,
+        FnT: Fn(&mut TulispContext, $($arg,)* $(Option<$opt>,)* Rest<RestT>) -> OutT + 'static + SyncSend,
         $($arg: TryFrom<TulispObject, Error = Error> + 'static,)*
         $($opt: TryFrom<TulispObject, Error = Error> + 'static,)*
         RestT: TryFrom<TulispObject, Error = Error> + Into<TulispObject> + 'static,
@@ -290,7 +291,7 @@ macro_rules! impl_tulisp_callable {
         impl<RestT, FnT, $($arg,)* $($opt,)*>
         TulispCallable<($($arg,)* $($opt,)* RestT,), (), true, $args_count, $opts_count, true, false, false> for FnT
         where
-        FnT: Fn(&mut TulispContext, $($arg,)* $(Option<$opt>,)* Rest<RestT>) + 'static,
+        FnT: Fn(&mut TulispContext, $($arg,)* $(Option<$opt>,)* Rest<RestT>) + 'static + SyncSend,
         $($arg: TryFrom<TulispObject, Error = Error> + 'static,)*
         $($opt: TryFrom<TulispObject, Error = Error> + 'static,)*
         RestT: TryFrom<TulispObject, Error = Error> + Into<TulispObject> + 'static,
@@ -327,7 +328,7 @@ macro_rules! impl_tulisp_callable {
         impl<RestT, OutT, FnT, $($arg,)* $($opt,)*>
         TulispCallable<($($arg,)* $($opt,)* RestT,), OutT, false, $args_count, $opts_count, true, true, true> for FnT
         where
-        FnT: Fn($($arg,)* $(Option<$opt>,)* Rest<RestT>) -> Result<OutT, Error> + 'static,
+        FnT: Fn($($arg,)* $(Option<$opt>,)* Rest<RestT>) -> Result<OutT, Error> + 'static + SyncSend,
         $($arg: TryFrom<TulispObject, Error = Error> + 'static,)*
         $($opt: TryFrom<TulispObject, Error = Error> + 'static,)*
         RestT: TryFrom<TulispObject, Error = Error> + Into<TulispObject> + 'static,
@@ -364,7 +365,7 @@ macro_rules! impl_tulisp_callable {
         impl<RestT, OutT, FnT, $($arg,)* $($opt,)*>
         TulispCallable<($($arg,)* $($opt,)* RestT,), OutT, true, $args_count, $opts_count, true, true, true> for FnT
         where
-        FnT: Fn(&mut TulispContext, $($arg,)* $(Option<$opt>,)* Rest<RestT>) -> Result<OutT, Error> + 'static,
+        FnT: Fn(&mut TulispContext, $($arg,)* $(Option<$opt>,)* Rest<RestT>) -> Result<OutT, Error> + 'static + SyncSend,
         $($arg: TryFrom<TulispObject, Error = Error> + 'static,)*
         $($opt: TryFrom<TulispObject, Error = Error> + 'static,)*
         RestT: TryFrom<TulispObject, Error = Error> + Into<TulispObject> + 'static,
diff --git a/src/lib.rs b/src/lib.rs
index 003d5083..207a1ac6 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -99,7 +99,7 @@ pub use value::TulispAny;
 pub use value::TulispValue;
 
 mod object;
-pub use object::TulispObject;
+pub use {object::TulispObject, object::wrappers::generic::Shared};
 
 #[cfg(test)]
 mod test_utils {
diff --git a/src/object.rs b/src/object.rs
index 55632037..af1e86b7 100644
--- a/src/object.rs
+++ b/src/object.rs
@@ -1,14 +1,12 @@
+pub mod wrappers;
+
 use crate::{
     TulispValue,
     cons::{self, Cons},
     error::Error,
+    object::wrappers::generic::{Shared, SharedMut, SharedRef},
     value::TulispAny,
 };
-use std::{
-    any::Any,
-    cell::{Cell, Ref, RefCell},
-    rc::Rc,
-};
 
 #[derive(Debug, Clone, PartialEq, Eq, Copy)]
 pub struct Span {
@@ -30,8 +28,8 @@ impl Span {
 /// A type for representing tulisp objects.
 #[derive(Debug, Clone)]
 pub struct TulispObject {
-    rc: Rc<RefCell<TulispValue>>,
-    span: Rc<Cell<Option<Span>>>,
+    rc: SharedMut<TulispValue>,
+    span: SharedMut<Option<Span>>,
 }
 
 impl Default for TulispObject {
@@ -281,7 +279,7 @@ impl TulispObject {
         "Returns a string if `self` contains a string, and an Error otherwise."
     );
     extractor_fn_with_err!(
-        Rc<dyn Any>,
+        Shared<dyn TulispAny>,
         as_any,
         r#"Returns a boxed value if `self` contains a boxed value, and an Error otherwise.
 
@@ -290,8 +288,7 @@ with `as_any`, and downcast to desired types.
 
 ## Example
 ```rust
-# use tulisp::{TulispContext, destruct_bind, Error, TulispAny};
-# use std::rc::Rc;
+# use tulisp::{TulispContext, destruct_bind, Error, TulispAny, Shared};
 #
 # fn main() -> Result<(), Error> {
 let mut ctx = TulispContext::new();
@@ -310,7 +307,7 @@ ctx.add_special_form("make_any", |_ctx, args| {
     destruct_bind!((inp) = args);
     let inp: i64 = inp.try_into()?;
 
-    let any_obj: Rc<dyn TulispAny> = Rc::new(TestStruct { value: inp });
+    let any_obj = Shared::new_any(TestStruct { value: inp });
 
     Ok(any_obj.into())
 });
@@ -372,8 +369,8 @@ impl TulispObject {
 
     pub(crate) fn new(vv: TulispValue, span: Option<Span>) -> TulispObject {
         Self {
-            rc: Rc::new(RefCell::new(vv)),
-            span: Rc::new(Cell::new(span)),
+            rc: SharedMut::new(vv),
+            span: SharedMut::new(span),
         }
     }
 
@@ -396,7 +393,7 @@ impl TulispObject {
 
     #[inline(always)]
     pub(crate) fn eq_ptr(&self, other: &TulispObject) -> bool {
-        Rc::ptr_eq(&self.rc, &other.rc)
+        self.rc.ptr_eq(&other.rc)
     }
 
     #[inline(always)]
@@ -405,19 +402,19 @@ impl TulispObject {
     }
 
     pub(crate) fn addr_as_usize(&self) -> usize {
-        self.rc.as_ptr() as usize
+        self.rc.addr_as_usize()
     }
 
     pub(crate) fn clone_without_span(&self) -> Self {
         Self {
-            rc: Rc::clone(&self.rc),
-            span: Rc::new(Cell::new(None)),
+            rc: self.rc.clone(),
+            span: SharedMut::new(None),
         }
     }
 
     #[inline(always)]
     pub(crate) fn strong_count(&self) -> usize {
-        Rc::strong_count(&self.rc)
+        self.rc.strong_count()
     }
 
     #[inline(always)]
@@ -430,7 +427,7 @@ impl TulispObject {
     }
 
     #[inline(always)]
-    pub(crate) fn inner_ref(&self) -> Ref<'_, TulispValue> {
+    pub(crate) fn inner_ref(&self) -> SharedRef<'_, TulispValue> {
         self.rc.borrow()
     }
 
@@ -448,7 +445,7 @@ impl TulispObject {
     }
 
     pub(crate) fn with_span(&self, in_span: Option<Span>) -> Self {
-        self.span.set(in_span);
+        *self.span.borrow_mut() = in_span;
         self.clone()
     }
     pub(crate) fn take(&self) -> TulispValue {
@@ -458,7 +455,7 @@ impl TulispObject {
     #[doc(hidden)]
     #[inline(always)]
     pub fn span(&self) -> Option<Span> {
-        self.span.get()
+        self.span.borrow().clone()
     }
 
     #[doc(hidden)]
@@ -552,7 +549,7 @@ impl From<TulispObject> for bool {
     }
 }
 
-impl TryFrom<TulispObject> for Rc<dyn Any> {
+impl TryFrom<TulispObject> for Shared<dyn TulispAny> {
     type Error = Error;
 
     fn try_from(value: TulispObject) -> Result<Self, Self::Error> {
@@ -575,7 +572,7 @@ tulisp_object_from!(f64);
 tulisp_object_from!(&str);
 tulisp_object_from!(String);
 tulisp_object_from!(bool);
-tulisp_object_from!(Rc<dyn TulispAny>);
+tulisp_object_from!(Shared<dyn TulispAny>);
 
 impl FromIterator<TulispObject> for TulispObject {
     fn from_iter<T: IntoIterator<Item = TulispObject>>(iter: T) -> Self {
diff --git a/src/object/wrappers.rs b/src/object/wrappers.rs
new file mode 100644
index 00000000..b9ce14b4
--- /dev/null
+++ b/src/object/wrappers.rs
@@ -0,0 +1,231 @@
+use crate::{Error, TulispContext, TulispObject};
+
+#[cfg(not(feature = "sync"))]
+pub mod generic {
+    use std::ops::Deref;
+
+    use crate::TulispAny;
+
+    use super::*;
+
+    pub trait SyncSend {}
+    impl<T> SyncSend for T {}
+
+    #[repr(transparent)]
+    #[derive(Debug)]
+    pub struct Shared<T: ?Sized>(std::rc::Rc<T>);
+
+    pub type SharedRef<'a, T> = std::cell::Ref<'a, T>;
+
+    impl<T: ?Sized + std::fmt::Display> std::fmt::Display for Shared<T> {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "Shared({})", self.0)
+        }
+    }
+
+    impl<T: ?Sized> Clone for Shared<T> {
+        fn clone(&self) -> Self {
+            Self(self.0.clone())
+        }
+    }
+
+    impl Shared<dyn TulispAny> {
+        pub fn new_tulisp_fn(val: impl TulispFn) -> Shared<dyn TulispFn> {
+            Shared(std::rc::Rc::new(val))
+        }
+
+        pub fn new_any(val: impl TulispAny) -> Shared<dyn TulispAny> {
+            Shared(std::rc::Rc::new(val))
+        }
+
+        pub fn downcast_ref<U: TulispAny + 'static>(&self) -> Option<&U> {
+            let a: &dyn std::any::Any = &*self.0;
+            a.downcast_ref::<U>()
+        }
+
+        pub fn downcast<U: TulispAny + 'static>(self) -> Result<Shared<U>, Shared<dyn TulispAny>> {
+            match std::rc::Rc::downcast::<U>(self.0.clone()) {
+                Ok(v) => Ok(Shared(v)),
+                Err(_) => Err(Shared(self.0)),
+            }
+        }
+    }
+
+    impl<T> Shared<T> {
+        pub fn new(val: T) -> Self {
+            Shared(std::rc::Rc::new(val))
+        }
+
+        pub fn ptr_eq(&self, other: &Self) -> bool {
+            std::rc::Rc::ptr_eq(&self.0, &other.0)
+        }
+    }
+
+    impl<T: ?Sized> Deref for Shared<T> {
+        type Target = T;
+
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+
+    impl<T: ?Sized> std::ops::DerefMut for Shared<T> {
+        fn deref_mut(&mut self) -> &mut Self::Target {
+            std::rc::Rc::get_mut(&mut self.0).expect("Multiple references exist")
+        }
+    }
+
+    #[repr(transparent)]
+    #[derive(Clone, Debug)]
+    pub struct SharedMut<T>(std::rc::Rc<std::cell::RefCell<T>>);
+
+    impl<T> SharedMut<T> {
+        pub fn new(val: T) -> Self {
+            SharedMut(std::rc::Rc::new(std::cell::RefCell::new(val)))
+        }
+        pub fn ptr_eq(&self, other: &Self) -> bool {
+            std::rc::Rc::ptr_eq(&self.0, &other.0)
+        }
+
+        pub fn borrow(&self) -> std::cell::Ref<'_, T> {
+            self.0.borrow()
+        }
+
+        pub fn borrow_mut(&self) -> std::cell::RefMut<'_, T> {
+            self.0.borrow_mut()
+        }
+
+        pub fn addr_as_usize(&self) -> usize {
+            self.0.as_ptr() as usize
+        }
+
+        pub fn strong_count(&self) -> usize {
+            std::rc::Rc::strong_count(&self.0)
+        }
+    }
+
+    impl<T> Deref for SharedMut<T> {
+        type Target = T;
+
+        fn deref(&self) -> &Self::Target {
+            todo!()
+        }
+    }
+
+    pub trait TulispFn:
+        Fn(&mut TulispContext, &TulispObject) -> Result<TulispObject, Error> + 'static
+    {
+    }
+    impl<T> TulispFn for T where
+        T: Fn(&mut TulispContext, &TulispObject) -> Result<TulispObject, Error> + 'static
+    {
+    }
+}
+
+#[cfg(feature = "sync")]
+pub mod generic {
+    use std::ops::Deref;
+
+    use crate::TulispAny;
+
+    use super::*;
+
+    pub trait SyncSend: Sync + Send {}
+    impl<T> SyncSend for T where T: Send + Sync {}
+
+    #[repr(transparent)]
+    #[derive(Debug)]
+    pub struct Shared<T: ?Sized>(std::sync::Arc<T>);
+
+    pub type SharedRef<'a, T> = std::sync::RwLockReadGuard<'a, T>;
+
+    impl<T: ?Sized + std::fmt::Display> std::fmt::Display for Shared<T> {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "Shared({})", self.0)
+        }
+    }
+
+    impl<T: ?Sized> Clone for Shared<T> {
+        fn clone(&self) -> Self {
+            Self(self.0.clone())
+        }
+    }
+
+    impl Shared<dyn TulispAny> {
+        pub fn new_tulisp_fn(val: impl TulispFn) -> Shared<dyn TulispFn> {
+            Shared(std::sync::Arc::new(val))
+        }
+
+        pub fn new_any(val: impl TulispAny) -> Shared<dyn TulispAny> {
+            Shared(std::sync::Arc::new(val))
+        }
+
+        pub fn downcast_ref<U: TulispAny + 'static>(&self) -> Option<&U> {
+            let a: &dyn std::any::Any = &*self.0;
+            a.downcast_ref::<U>()
+        }
+
+        pub fn downcast<U: TulispAny + 'static>(self) -> Result<Shared<U>, Shared<dyn TulispAny>> {
+            match std::sync::Arc::downcast::<U>(self.0.clone()) {
+                Ok(v) => Ok(Shared(v)),
+                Err(_) => Err(Shared(self.0)),
+            }
+        }
+    }
+
+    impl<T> Shared<T> {
+        pub fn new(val: T) -> Self {
+            Shared(std::sync::Arc::new(val))
+        }
+
+        pub fn ptr_eq(&self, other: &Self) -> bool {
+            std::sync::Arc::ptr_eq(&self.0, &other.0)
+        }
+    }
+
+    impl<T: ?Sized> Deref for Shared<T> {
+        type Target = T;
+
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+
+    #[repr(transparent)]
+    #[derive(Clone, Debug)]
+    pub struct SharedMut<T>(std::sync::Arc<std::sync::RwLock<T>>);
+    impl<T> SharedMut<T> {
+        pub fn new(val: T) -> Self {
+            SharedMut(std::sync::Arc::new(std::sync::RwLock::new(val)))
+        }
+        pub fn ptr_eq(&self, other: &Self) -> bool {
+            std::sync::Arc::ptr_eq(&self.0, &other.0)
+        }
+
+        pub fn borrow(&self) -> std::sync::RwLockReadGuard<'_, T> {
+            self.0.read().unwrap()
+        }
+
+        pub fn borrow_mut(&self) -> std::sync::RwLockWriteGuard<'_, T> {
+            self.0.write().unwrap()
+        }
+
+        pub fn addr_as_usize(&self) -> usize {
+            std::sync::Arc::as_ptr(&self.0) as usize
+        }
+
+        pub fn strong_count(&self) -> usize {
+            std::sync::Arc::strong_count(&self.0)
+        }
+    }
+    pub trait TulispFn:
+        Fn(&mut TulispContext, &TulispObject) -> Result<TulispObject, Error> + SyncSend + 'static
+    {
+    }
+    impl<T> TulispFn for T where
+        T: Fn(&mut TulispContext, &TulispObject) -> Result<TulispObject, Error>
+            + SyncSend
+            + 'static
+    {
+    }
+}
diff --git a/src/value.rs b/src/value.rs
index c36d6f80..ae63d83f 100644
--- a/src/value.rs
+++ b/src/value.rs
@@ -1,15 +1,17 @@
 use crate::{
-    TulispContext, TulispObject,
+    TulispObject,
     cons::{self, Cons},
     context::Scope,
     error::Error,
-    object::Span,
+    object::{
+        Span,
+        wrappers::generic::{Shared, SyncSend, TulispFn},
+    },
 };
 use std::{
     any::Any,
     convert::TryInto,
     fmt::{Display, Write},
-    rc::Rc,
 };
 
 #[doc(hidden)]
@@ -98,8 +100,6 @@ impl DefunParams {
     }
 }
 
-type TulispFn = dyn Fn(&mut TulispContext, &TulispObject) -> Result<TulispObject, Error>;
-
 #[derive(Default, Clone, Debug)]
 pub struct SymbolBindings {
     name: String,
@@ -199,8 +199,15 @@ impl SymbolBindings {
     }
 }
 
-pub trait TulispAny: Any + Display {}
-impl<T: Any + Display> TulispAny for T {}
+pub trait TulispAny: Any + Display + SyncSend {}
+
+impl std::fmt::Debug for dyn TulispAny {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "TulispAny({})", self)
+    }
+}
+
+impl<T: Any + Display + SyncSend> TulispAny for T {}
 
 #[doc(hidden)]
 #[derive(Clone)]
@@ -243,9 +250,9 @@ pub enum TulispValue {
     Splice {
         value: TulispObject,
     },
-    Any(Rc<dyn TulispAny>),
-    Func(Rc<TulispFn>),
-    Macro(Rc<TulispFn>),
+    Any(Shared<dyn TulispAny>),
+    Func(Shared<dyn TulispFn>),
+    Macro(Shared<dyn TulispFn>),
     Defmacro {
         params: DefunParams,
         body: TulispObject,
@@ -722,11 +729,11 @@ impl TulispValue {
     }
 
     #[inline(always)]
-    pub(crate) fn as_any(&self) -> Result<Rc<dyn Any>, Error> {
+    pub(crate) fn as_any(&self) -> Result<Shared<dyn TulispAny>, Error> {
         match self {
             TulispValue::Any(value) => Ok(value.clone()),
             _ => Err(Error::type_mismatch(format!(
-                "Expected Any(Rc<dyn TulispAny>), got: {}",
+                "Expected Any(Shared<dyn TulispAny>), got: {}",
                 self
             ))),
         }
@@ -821,8 +828,8 @@ impl From<bool> for TulispValue {
     }
 }
 
-impl From<Rc<dyn TulispAny>> for TulispValue {
-    fn from(value: Rc<dyn TulispAny>) -> Self {
+impl From<Shared<dyn TulispAny>> for TulispValue {
+    fn from(value: Shared<dyn TulispAny>) -> Self {
         TulispValue::Any(value)
     }
 }
diff --git a/tests/tests.rs b/tests/tests.rs
index 8a8c29b8..45242fa2 100644
--- a/tests/tests.rs
+++ b/tests/tests.rs
@@ -1,5 +1,5 @@
-use std::{fmt::Display, rc::Rc};
-use tulisp::{Error, Iter, TulispAny, TulispContext, TulispObject, destruct_eval_bind};
+use std::fmt::Display;
+use tulisp::{Error, Iter, Shared, TulispAny, TulispContext, TulispObject, destruct_eval_bind};
 
 macro_rules! tulisp_assert {
     (@impl $ctx: expr, program:$input:expr, result:$result:expr $(,)?) => {
@@ -1165,7 +1165,7 @@ fn test_any() -> Result<(), Error> {
 
     ctx.add_special_form("make_any", |ctx, args| {
         destruct_eval_bind!(ctx, (inp) = args);
-        let res: Rc<dyn TulispAny> = Rc::new(TestStruct {
+        let res: Shared<dyn TulispAny> = Shared::new_any(TestStruct {
             value: inp.try_into()?,
         });
 
@@ -1190,7 +1190,7 @@ fn test_any() -> Result<(), Error> {
     tulisp_assert! {
         ctx: ctx,
         program: "(get_int 55)",
-        error: r#"ERR TypeMismatch: Expected Any(Rc<dyn TulispAny>), got: 55
+        error: r#"ERR TypeMismatch: Expected Any(Shared<dyn TulispAny>), got: 55
 <eval_string>:1.10-1.11:  at 55
 <eval_string>:1.1-1.12:  at (get_int 55)
 "#