diff --git a/aos/complex_thread_local.h b/aos/complex_thread_local.h
new file mode 100644
index 0000000..224d3b2
--- /dev/null
+++ b/aos/complex_thread_local.h
@@ -0,0 +1,131 @@
+#ifndef AOS_COMPLEX_THREAD_LOCAL_H_
+#define AOS_COMPLEX_THREAD_LOCAL_H_
+
+#include <assert.h>
+
+#include <type_traits>
+#include <utility>
+
+namespace aos {
+
+// Instances form a (per-thread) list of destructor functions to call when the
+// thread exits.
+// Only ComplexThreadLocal should use this.
+struct ComplexThreadLocalDestructor {
+  // Adds this to the list of destructors in this thread.
+  void Add();
+  // Removes this from the list of destructors in this thread. ::aos::Dies if it
+  // is not there.
+  void Remove();
+
+  void (*function)(void *);
+  void *param;
+
+  ComplexThreadLocalDestructor *next;
+};
+
+// Handles creating a thread-local (per type) object with non-trivial
+// constructor and/or destructor. It will be correctly destroyed on thread exit.
+//
+// Each thread using an instantiation of this class has its own independent slot
+// for storing a T. An instance of T is not actually constructed until a thread
+// calls Create, after which a pointer to it will be returned from get() etc
+// until after Clear is called.
+//
+// Example usage:
+// class Something {
+//  private:
+//   class Data {
+//    public:
+//     Data(const ::std::string &value) : value_(value) {}
+//
+//     int DoSomething() {
+//       if (cached_result_ == 0) {
+//         // Do something expensive with value_ and store it in
+//         // cached_result_.
+//       }
+//       return cached_result_;
+//     }
+//
+//    private:
+//     const ::std::string value_;
+//     int cached_result_ = 0;
+//   };
+//   ComplexThreadLocal<Data> thread_local_;
+//   ::std::string a_string_;
+//
+//   int DoSomething() {
+//     thread_local_.Create(a_string_);
+//     return thread_local_->DoSomething();
+//   }
+// };
+//
+// The current implementation is based on
+// <http://stackoverflow.com/questions/12049684/gcc-4-7-on-linux-pthreads-nontrivial-thread-local-workaround-using-thread-n>.
+// TODO(brians): Change this to just simple standard C++ thread_local once all
+// of our compilers have support.
+template <typename T>
+class ComplexThreadLocal {
+ public:
+  // Actually creates the object in this thread if there is not one there
+  // already.
+  // args are all perfectly forwarded to the constructor.
+  template <typename... Args>
+  void Create(Args &&... args) {
+    if (initialized) return;
+    new (&storage) T(::std::forward<Args>(args)...);
+    destructor.function = PlacementDelete;
+    destructor.param = &storage;
+    destructor.Add();
+    initialized = true;
+  }
+
+  // Removes the object in this thread (if any), including calling its
+  // destructor.
+  void Clear() {
+    if (!initialized) return;
+    destructor.Remove();
+    PlacementDelete(&storage);
+    initialized = false;
+  }
+
+  // Returns true if there is already an object in this thread.
+  bool created() const { return initialized; }
+
+  // Returns the object currently created in this thread or nullptr.
+  T *operator->() const {
+    return get();
+  }
+  T *get() const {
+    if (initialized) {
+      return static_cast<T *>(static_cast<void *>(&storage));
+    } else {
+      return nullptr;
+    }
+  }
+
+ private:
+  typedef typename ::std::aligned_storage<
+      sizeof(T), ::std::alignment_of<T>::value>::type Storage;
+
+  // Convenient helper for calling a destructor.
+  static void PlacementDelete(void *t) { static_cast<T *>(t)->~T(); }
+
+  // True iff this storage has been initialized.
+  static __thread bool initialized;
+  // Where we actually store the object for this thread (if any).
+  static __thread Storage storage;
+  // The linked list element representing this storage.
+  static __thread ComplexThreadLocalDestructor destructor;
+};
+
+template <typename T>
+__thread bool ComplexThreadLocal<T>::initialized;
+template <typename T>
+__thread typename ComplexThreadLocal<T>::Storage ComplexThreadLocal<T>::storage;
+template <typename T>
+__thread ComplexThreadLocalDestructor ComplexThreadLocal<T>::destructor;
+
+}  // namespace aos
+
+#endif  // AOS_COMPLEX_THREAD_LOCAL_H_