diff --git a/README.md b/README.md
index 25791bd..dca614e 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,98 @@
 # Tween
+
 Tween library for Arduino
+
+
+## Usage
+
+```C++
+#include <Tween.h>
+
+Tween::Timeline timeline;
+float target = 0.f;
+
+void setup()
+{
+    timeline.add(target, 10, 5000) // target tweens to 10 in 5000[ms]
+        .then(5, 5000)             // then to 5 in 5000[ms]
+        .wait(1000)                // then stops 1000[ms]
+        .then(0, 5000);            // then to 0 in 5000[ms]
+
+    timeline.start();
+}
+
+void loop()
+{
+    timline.update(); // must be called to tween target
+
+    Serial.println(target); // target value tweens automatically
+}
+```
+
+### Use Easing Function in Tween
+
+```C++
+timeline.add<Ease::Sine>(f, 10, 5000)
+    .then<Ease::Elastic>(5, 5000)
+    .wait(1000)
+    .then<Ease::Bounce>(0, 5000);
+```
+
+
+## Easing Types
+
+If you haven't specify the easing type, default value is `Ease::Linear`.
+
+- BackIn, BackOut, BackInOut
+- BounceIn, BounceOut, BounceInOut
+- CircIn, CircOut, CircInOut
+- CubicIn, CubicOut, CubicInOut
+- ElasticIn, ElasticOut, ElasticInOut
+- ExpoIn, ExpoOut, ExpoInOut
+- LinearIn, LinearOut, LinearInOut
+- QuadIn, QuadOut, QuadInOut
+- QuartIn, QuartOut, QuartInOut
+- QuintIn, QuintOut, QuintInOut
+- SineIn, SineOut, SineInOut
+
+```C++
+// alias
+using Back = BackInOut;
+using Bounce = BounceInOut;
+using Circ = CircInOut;
+using Cubic = CubicInOut;
+using Elastic = ElasticInOut;
+using Expo = ExpoInOut;
+using Linear = LinearInOut;
+using Quad = QuadInOut;
+using Quart = QuartInOut;
+using Quint = QuintInOut;
+using Sine = SineInOut;
+```
+
+
+## Custom Class Adaptation
+
+You can use custom classes if you have implemented following operators.
+
+- `operator+(const T&)`
+- `operator-(const T&)`
+- `operator*(const double)`
+
+If you have these operator overloads, you can use that variable completely as same as other built-in variables.
+Please see `custom_class` example for details.
+
+
+## Embedded Libraries
+
+- [Easing v0.1.0](https://github.com/hideakitai/Easing)
+- [PollingTimer v0.2.0](https://github.com/hideakitai/PollingTimer)
+- [ArxTypeTraits v0.1.11](https://github.com/hideakitai/ArxTypeTraits)
+- [ArxContainer v0.3.6](https://github.com/hideakitai/ArxContainer)
+- [ArxSmartPtr v0.1.1](https://github.com/hideakitai/ArxSmartPtr)
+- [TeensyDirtySTLErrorSolution v0.1.0](https://github.com/hideakitai/TeensyDirtySTLErrorSolution)
+
+
+## License
+
+MIT
diff --git a/Tween.h b/Tween.h
new file mode 100644
index 0000000..91af933
--- /dev/null
+++ b/Tween.h
@@ -0,0 +1,8 @@
+#ifndef ARDUINOTWEEN_H
+#define ARDUINOTWEEN_H
+
+#include "Tween/Timeline.h"
+
+namespace Tween = ht::tween;
+
+#endif // ARDUINOTWEEN_H
diff --git a/Tween/Sequence.h b/Tween/Sequence.h
new file mode 100644
index 0000000..f01957d
--- /dev/null
+++ b/Tween/Sequence.h
@@ -0,0 +1,107 @@
+#pragma once
+#ifndef HT_TWEEN_SEQUENCE_H
+#define HT_TWEEN_SEQUENCE_H
+
+#include "Types.h"
+#include "Transition.h"
+
+namespace ht {
+namespace tween {
+
+namespace sequence {
+
+    struct Base
+    {
+        virtual ~Base() {}
+        virtual void update(const uint32_t curr_ms) = 0;
+    };
+
+
+    template <typename T>
+    class Sequence : public Base
+    {
+        struct trans_t
+        {
+            int32_t begin_ms;
+            int32_t end_ms;
+            TransitionRef ref;
+        };
+
+        T& target;
+        T prev_target;
+        Vec<trans_t> transitions;
+
+    public:
+
+        virtual ~Sequence() {}
+
+        template <typename EasingType = Ease::Linear, typename U = T>
+        Sequence(T& from, const U& to, const int32_t in, const EasingType&,
+            typename std::enable_if<std::is_convertible<U, T>::value>::type* = nullptr
+        )
+        : target(from)
+        {
+            transitions.emplace_back(trans_t{0, in, make_shared<Transition<T, EasingType>>(target, from, to, in)});
+            prev_target = (T)to;
+        }
+
+        template <typename EasingType = Ease::Linear, typename U = T>
+        auto then(const U& to, const int32_t in)
+        -> typename std::enable_if<std::is_convertible<U, T>::value, Sequence<T>&>::type
+        {
+            transitions.emplace_back(trans_t{duration(), duration() + in, make_shared<Transition<T, EasingType>>(target, prev_target, to, in)});
+            prev_target = (T)to;
+            return *this;
+        }
+
+        Sequence<T>& wait(const int32_t in)
+        {
+            transitions.emplace_back(trans_t{duration(), duration() + in, make_shared<Transition<T, Ease::Linear>>(target, prev_target, prev_target, in)});
+            return *this;
+        }
+
+        virtual void update(const uint32_t curr_ms) override
+        {
+            if (transitions.empty()) return;
+
+            const size_t idx = from_time_to_index(curr_ms);
+            if (idx >= transitions.size()) return;
+
+            transitions[idx].ref->update(curr_ms - transitions[idx].begin_ms);
+        }
+
+        int32_t duration() const
+        {
+            int32_t duration_ms = 0;
+            for (const auto& t : transitions)
+                duration_ms += t.ref->duration();
+            return duration_ms;
+        }
+
+        size_t size() const { return transitions.size(); }
+        bool empty() const { return transitions.size() == 0; }
+        void clear() { transitions.clear(); }
+
+    private:
+
+        size_t from_time_to_index(const int32_t ms) const
+        {
+            if (ms < 0) return 0;
+            for (size_t i = 0; i < transitions.size(); ++i)
+                if (transitions[i].end_ms > ms)
+                    return i;
+            return transitions.size();
+        }
+
+    };
+
+} // sequence
+
+template <typename T>
+using Sequence = sequence::Sequence<T>;
+using SequenceRef = Ref<sequence::Base>;
+
+} // tween
+} // ht
+
+#endif // HT_TWEEN_SEQUENCE_H
diff --git a/Tween/Timeline.h b/Tween/Timeline.h
new file mode 100644
index 0000000..55c1930
--- /dev/null
+++ b/Tween/Timeline.h
@@ -0,0 +1,44 @@
+
+#ifndef TWEEN_DUINO_TIMELINE_H
+#define TWEEN_DUINO_TIMELINE_H
+
+#include "Types.h"
+#include "Sequence.h"
+#include "util/PollingTimer/PollingTimer.h"
+
+namespace ht {
+namespace tween {
+
+class Timeline : public PollingTimer
+{
+    Map<void*, SequenceRef> seqs;
+
+public:
+
+    template <typename EasingType = Ease::Linear, typename T, typename U>
+    auto add(T& target, const U& to, const int32_t in)
+    -> typename std::enable_if<std::is_convertible<U, T>::value, Sequence<T>&>::type
+    {
+        auto p = make_shared<Sequence<T>>(target, to, in, EasingType());
+        seqs.insert(make_pair((void*)&target, (SequenceRef)p));
+        return *p;
+    }
+
+    void update()
+    {
+        if (!isRunning()) return;
+        for (auto& s : seqs)
+            s.second->update(msec());
+    }
+
+    void clear()
+    {
+        seqs.clear();
+        PollingTimer::stop();
+    }
+};
+
+} // tween
+} // ht
+
+#endif
\ No newline at end of file
diff --git a/Tween/Transition.h b/Tween/Transition.h
new file mode 100644
index 0000000..20f3ab6
--- /dev/null
+++ b/Tween/Transition.h
@@ -0,0 +1,99 @@
+#pragma once
+#ifndef HT_TWEEN_TRANSITION_H
+#define HT_TWEEN_TRANSITION_H
+
+#include "Types.h"
+#include "util/Easing/Easing.h"
+
+struct CRGB;
+struct CHSV;
+
+namespace ht {
+namespace tween {
+
+namespace transition
+{
+    struct Base
+    {
+        virtual ~Base() {}
+        virtual bool update(const int32_t t) = 0;
+        virtual int32_t duration() const = 0;
+    };
+
+
+    template <typename T, typename EasingType>
+    class Transition : public Base
+    {
+        T& ref;
+        const T from;
+        const T to;
+        const T diff;
+        const int32_t duration_ms;
+        EasingFunc<EasingType> ease;
+
+    public:
+
+        Transition(T& target, const T& from, const T& to, const int32_t in)
+        : ref(target)
+        , from(from)
+        , to(to)
+        , diff(to - from)
+        , duration_ms(in)
+        {
+        }
+
+        virtual ~Transition() {}
+
+        virtual bool update(const int32_t t) override
+        {
+            if (t < 0)
+                ref = from;
+            else if (t > duration_ms)
+                ref = to;
+            else
+            {
+                ref = lerp(t);
+                return true;
+            }
+            return false;
+        }
+
+        virtual int32_t duration() const { return duration_ms; }
+
+    private:
+
+        template <typename U = T>
+        auto lerp(const float t)
+        -> typename std::enable_if<
+            !std::is_same<U, CRGB>::value && !std::is_same<U, CHSV>::value,
+            U
+        >::type
+        {
+            return diff * ease.get((float)t / (float)duration_ms) + from;
+        }
+
+        template <typename U = T>
+        auto lerp(const float t)
+        -> typename std::enable_if<
+            std::is_same<U, CRGB>::value || std::is_same<U, CHSV>::value,
+            U
+        >::type
+        {
+            float rgb[3];
+            const float rate = ease.get((float)t / (float)duration_ms);
+            for (size_t i = 0; i < 3; ++i)
+                rgb[i] = ((float)to[i] - (float)from[i]) * rate + (float)from[i];
+            return U(rgb[0], rgb[1], rgb[2]);
+        }
+    };
+
+} // transition
+
+template <typename T, typename EasingType>
+using Transition = transition::Transition<T, EasingType>;
+using TransitionRef = Ref<transition::Base>;
+
+} // tween
+} // ht
+
+#endif // HT_TWEEN_TRANSITION_H
diff --git a/Tween/Types.h b/Tween/Types.h
new file mode 100644
index 0000000..75a1aa7
--- /dev/null
+++ b/Tween/Types.h
@@ -0,0 +1,43 @@
+#pragma once
+#ifndef HT_TWEEN_TYPES_H
+#define HT_TWEEN_TYPES_H
+
+#if defined(ARDUINO_ARCH_AVR)\
+ || defined(ARDUINO_ARCH_MEGAAVR)\
+ || defined(ARDUINO_ARCH_SAMD)\
+ || defined(ARDUINO_spresense_ast)
+    #define HT_TWEEN_STL_DISABLED
+#endif
+
+#include <Arduino.h>
+#ifdef HT_TWEEN_STL_DISABLED
+    #include "Tween/util/TeensyDirtySTLErrorSolution/TeensyDirtySTLErrorSolution.h"
+    #include "Tween/util/ArxTypeTraits/ArxTypeTraits.h"
+    #include "Tween/util/ArxContainer/ArxContainer.h"
+    #include "Tween/util/ArxSmartPtr/ArxSmartPtr.h"
+#else
+    #include <vector>
+    #include <map>
+    #include <memory>
+#endif
+
+namespace ht {
+namespace tween {
+
+#ifdef HT_TWEEN_STL_DISABLED
+    template <typename T, typename U> using Map = arx::map<T, U>;
+    template <typename T> using Vec = arx::vector<T>;
+    template <typename T> using Ref = arx::shared_ptr<T>;
+    using namespace arx;
+#else
+    template <typename T, typename U> using Map = std::map<T, U>;
+    template <typename T> using Vec = std::vector<T>;
+    template <typename T> using Ref = std::shared_ptr<T>;
+    using namespace std;
+#endif // HT_TWEEN_STL_DISABLED
+
+} // tween
+} // ht
+
+
+#endif // HT_TWEEN_TYPES_H
diff --git a/Tween/util/ArxContainer/ArxContainer.h b/Tween/util/ArxContainer/ArxContainer.h
new file mode 100644
index 0000000..906318e
--- /dev/null
+++ b/Tween/util/ArxContainer/ArxContainer.h
@@ -0,0 +1,552 @@
+#pragma once
+
+#ifndef ARX_RINGBUFFER_H
+#define ARX_RINGBUFFER_H
+
+#include <Arduino.h>
+
+#if defined(ARDUINO_ARCH_AVR)\
+ || defined(ARDUINO_ARCH_MEGAAVR)\
+ || defined(ARDUINO_ARCH_SAMD)\
+ || defined(ARDUINO_spresense_ast)
+    #define ARX_CONTAINER_DISABLED
+#endif
+
+#ifdef ARX_CONTAINER_DISABLED
+
+#ifndef ARX_VECTOR_DEFAULT_SIZE
+#define ARX_VECTOR_DEFAULT_SIZE 16
+#endif // ARX_VECTOR_DEFAULT_SIZE
+
+#ifndef ARX_DEQUE_DEFAULT_SIZE
+#define ARX_DEQUE_DEFAULT_SIZE 16
+#endif // ARX_DEQUE_DEFAULT_SIZE
+
+#ifndef ARX_MAP_DEFAULT_SIZE
+#define ARX_MAP_DEFAULT_SIZE 16
+#endif // ARX_MAP_DEFAULT_SIZE
+
+#ifndef ARX_TYPE_TRAITS_INITIALIZER_LIST_DEFINED
+#define ARX_TYPE_TRAITS_INITIALIZER_LIST_DEFINED
+namespace std
+{
+    template<class T>
+    class initializer_list
+    {
+    private:
+        const T* array;
+        size_t len;
+        initializer_list(const T* a, size_t l) : array(a), len(l) {}
+    public:
+        initializer_list() : array(nullptr), len(0) {}
+        size_t size() const { return len; }
+        const T *begin() const { return array; }
+        const T *end() const { return array + len; }
+    };
+}
+#endif // ARX_TYPE_TRAITS_INITIALIZER_LIST_DEFINED
+
+namespace arx {
+
+    namespace container
+    {
+        namespace detail
+        {
+            template<class T>
+            T&& move(T& t){ return static_cast<T&&>(t); }
+        }
+    }
+
+    template<typename T, size_t N>
+    class RingBuffer
+    {
+    protected:
+
+        T queue_[N];
+        int head_ {0};
+        int tail_ {0};
+
+    public:
+
+        RingBuffer()
+        : queue_()
+        , head_ {0}
+        , tail_{0}
+        {
+        }
+
+        RingBuffer(std::initializer_list<T> lst)
+        : queue_()
+        , head_(0)
+        , tail_(0)
+        {
+            for (auto it = lst.begin() ; it != lst.end() ; ++it)
+            {
+                queue_[tail_] = *it;
+                ++tail_;
+            }
+        }
+
+        // copy
+        explicit RingBuffer(const RingBuffer& r)
+        : queue_()
+        , head_(r.head_)
+        , tail_(r.tail_)
+        {
+            for (size_t i = 0; i < r.size(); ++i)
+                queue_[i] = r.queue_[i];
+        }
+        RingBuffer& operator= (const RingBuffer& r)
+        {
+            head_ = r.head_;
+            tail_ = r.tail_;
+            for (size_t i = 0; i < r.size(); ++i)
+                queue_[i] = r.queue_[i];
+            return *this;
+        }
+
+        // move
+        RingBuffer(RingBuffer&& r)
+        {
+            head_ = container::detail::move(r.head_);
+            tail_ = container::detail::move(r.tail_);
+            for (size_t i = 0; i < r.size(); ++i)
+                queue_[i] = container::detail::move(r.queue_[i]);
+        }
+
+        RingBuffer& operator= (RingBuffer&& r)
+        {
+            head_ = container::detail::move(r.head_);
+            tail_ = container::detail::move(r.tail_);
+            for (size_t i = 0; i < r.size(); ++i)
+                queue_[i] = container::detail::move(r.queue_[i]);
+            return *this;
+        }
+
+        virtual ~RingBuffer() {}
+
+        using iterator = T*;
+        using const_iterator = const T*;
+
+        size_t capacity() const { return N; };
+        size_t size() const { return tail_ - head_; }
+        inline const T* data() const { return &(get(head_)); }
+        T* data() { return &(get(head_)); }
+        bool empty() const { return tail_ == head_; }
+        void clear() { head_ = 0; tail_ = 0; }
+
+        void pop() { pop_front(); }
+        void pop_front()
+        {
+            if (size() == 0) return;
+            if (size() == 1) clear();
+            else head_++;
+        }
+        void pop_back()
+        {
+            if (size() == 0) return;
+            if (size() == 1) clear();
+            else tail_--;
+        }
+
+        void push(const T& data) { push_back(data); }
+        void push(T&& data) { push_back(data); }
+        void push_back(const T& data)
+        {
+            get(tail_++) = data;
+            if (size() > N) ++head_;
+        };
+        void push_back(T&& data)
+        {
+            get(tail_++) = data;
+            if (size() > N) ++head_;
+        };
+        void push_front(const T& data)
+        {
+            get(head_--) = data;
+            if (size() > N) --tail_;
+        };
+        void push_front(T&& data)
+        {
+            get(head_--) = data;
+            if (size() > N) --tail_;
+        };
+        void emplace(const T& data) { push(data); }
+        void emplace(T&& data) { push(data); }
+        void emplace_back(const T& data) { push_back(data); }
+        void emplace_back(T&& data) { push_back(data); }
+
+        const T& front() const { return get(head_); };
+        T& front() { return get(head_); };
+
+        const T& back() const { return get(tail_ - 1); }
+        T& back() { return get(tail_ - 1); }
+
+        const T& operator[] (size_t index) const { return get(head_ + (int)index); }
+        T& operator[] (size_t index) { return get(head_ + (int)index); }
+
+        iterator begin() { return ptr(head_); }
+        iterator end() { return (queue_ + tail_); }
+
+        const_iterator begin() const { return (const_iterator)ptr(head_); }
+        const_iterator end() const { return (const_iterator)(queue_ + tail_); }
+
+        iterator erase(iterator p)
+        {
+            if (p == end()) return p;
+            for (T* pos = p + 1; pos != end(); ++pos)
+                *(pos - 1) = *pos;
+            --tail_;
+            return p;
+        }
+
+        void resize(size_t sz)
+        {
+            size_t s = size();
+            if (sz > size())
+            {
+                for (size_t i = 0; i < sz - s; ++i) push(T());
+            }
+            else if (sz < size())
+            {
+                for (size_t i = 0; i < s - sz; ++i) pop();
+            }
+        }
+
+        void assign(const_iterator first, const_iterator end)
+        {
+            clear();
+            const char* p = first;
+            while (p != end) push(*p++);
+        }
+
+        void shrink_to_fit()
+        {
+            // dummy
+        }
+
+        void reserve(size_t n)
+        {
+            (void)n;
+            // dummy
+        }
+
+        void insert(const_iterator pos, const_iterator first, const_iterator last)
+        {
+            if (pos != end())
+            {
+                size_t sz = 0;
+                {
+                    iterator it = (iterator)first;
+                    for (; it != last; ++it) ++sz;
+                }
+                iterator it = end() + sz - 1;
+                for (int i = sz; i > 0; --i, --it)
+                {
+                    *it = *(it - sz);
+                }
+                it = (iterator)pos;
+                for (size_t i = 0; i < sz; ++i)
+                {
+                    *it = *(first + i);
+                }
+            }
+            else
+            {
+                iterator it = (iterator)first;
+                for (; it != last; ++it)
+                {
+                    push_back(*it);
+                }
+            }
+        }
+
+    private:
+
+        T& get(const int i)
+        {
+            if (i >= 0) return queue_[i % N];
+            else        return queue_[N - abs(i % N)];
+        }
+
+        const T& get(const int i) const
+        {
+            if (i >= 0) return queue_[i % N];
+            else        return queue_[N - abs(i % N)];
+        }
+
+        T* ptr(const int i)
+        {
+            if (i >= 0) return (T*)(queue_ + i % N);
+            else        return (T*)(queue_ + N - abs(i % N));
+        }
+
+        const T* ptr(const int i) const
+        {
+            if (i >= 0) return (T*)(queue_ + i % N);
+            else        return (T*)(queue_ + N - abs(i % N));
+        }
+
+    };
+
+    template <typename T, size_t N>
+    bool operator== (const RingBuffer<T, N>& x, const RingBuffer<T, N>& y)
+    {
+        if (x.size() != y.size()) return false;
+        for (size_t i = 0; i < x.size(); ++i)
+            if (x[i] != y[i]) return false;
+        return true;
+    }
+
+    template <typename T, size_t N>
+    bool operator!= (const RingBuffer<T, N>& x, const RingBuffer<T, N>& y)
+    {
+        return !(x == y);
+    }
+
+
+    template <typename T, size_t N = ARX_VECTOR_DEFAULT_SIZE>
+    struct vector : public RingBuffer<T, N>
+    {
+        vector() : RingBuffer<T, N>() { }
+        vector(std::initializer_list<T> lst) : RingBuffer<T, N>(lst) { }
+
+        // copy
+        vector(const vector& r) : RingBuffer<T, N>(r) { }
+
+        vector& operator= (const vector& r)
+        {
+            RingBuffer<T, N>::operator=(r);
+            return *this;
+        }
+
+        // move
+        vector(vector&& r) : RingBuffer<T, N>(r) { }
+
+        vector& operator= (vector&& r)
+        {
+            RingBuffer<T, N>::operator=(r);
+            return *this;
+        }
+
+        virtual ~vector() {}
+
+    private:
+        using RingBuffer<T, N>::pop;
+        using RingBuffer<T, N>::pop_front;
+        using RingBuffer<T, N>::push;
+        using RingBuffer<T, N>::push_front;
+        using RingBuffer<T, N>::emplace;
+    };
+
+
+    template <typename T, size_t N = ARX_DEQUE_DEFAULT_SIZE>
+    struct deque : public RingBuffer<T, N>
+    {
+        deque() : RingBuffer<T, N>() { }
+        deque(std::initializer_list<T> lst) : RingBuffer<T, N>(lst) { }
+
+        // copy
+        deque(const deque& r) : RingBuffer<T, N>(r) { }
+
+        deque& operator= (const deque& r)
+        {
+            RingBuffer<T, N>::operator=(r);
+            return *this;
+        }
+
+        // move
+        deque(deque&& r) : RingBuffer<T, N>(r) { }
+
+        deque& operator= (deque&& r)
+        {
+            RingBuffer<T, N>::operator=(r);
+            return *this;
+        }
+
+        virtual ~deque() {}
+
+    private:
+        using RingBuffer<T, N>::capacity;
+        using RingBuffer<T, N>::pop;
+        using RingBuffer<T, N>::push;
+        using RingBuffer<T, N>::emplace;
+        using RingBuffer<T, N>::assign;
+        using RingBuffer<T, N>::begin;
+        using RingBuffer<T, N>::end;
+    };
+
+
+    template <class T1, class T2>
+    struct pair
+    {
+        T1 first;
+        T2 second;
+    };
+
+    template <class T1, class T2>
+    pair<T1, T2> make_pair(const T1& t1, const T2& t2)
+    {
+        return {t1, t2};
+    };
+
+    template <typename T1, typename T2>
+    bool operator== (const pair<T1, T2>& x, const pair<T1, T2>& y)
+    {
+        return (x.first == y.first) && (x.second == y.second);
+    }
+
+    template <typename T1, typename T2>
+    bool operator!= (const pair<T1, T2>& x, const pair<T1, T2>& y)
+    {
+        return !(x == y);
+    }
+
+
+    template <class Key, class T, size_t N = ARX_MAP_DEFAULT_SIZE>
+    struct map : public RingBuffer<pair<Key, T>, N>
+    {
+        using iterator = typename RingBuffer<pair<Key, T>, N>::iterator;
+        using const_iterator = typename RingBuffer<pair<Key, T>, N>::const_iterator;
+
+        map() : RingBuffer<pair<Key, T>, N>() { }
+        map(std::initializer_list<pair<Key, T>> lst) : RingBuffer<pair<Key, T>, N>(lst) { }
+
+        // copy
+        map(const map& r) : RingBuffer<pair<Key, T>, N>(r) { }
+
+        map& operator= (const map& r)
+        {
+            RingBuffer<pair<Key, T>, N>::operator=(r);
+            return *this;
+        }
+
+        // move
+        map(map&& r) : RingBuffer<T, N>(r) { }
+
+        map& operator= (map&& r)
+        {
+            RingBuffer<pair<Key, T>, N>::operator=(r);
+            return *this;
+        }
+
+        virtual ~map() {}
+
+        const_iterator find(const Key& key) const
+        {
+            for (size_t i = 0; i < this->size(); ++i)
+            {
+                const_iterator it = this->begin() + i;
+                if (key == it->first)
+                    return it;
+            }
+            return this->end();
+        }
+
+        pair<iterator, bool> insert(const Key& key, const T& t)
+        {
+            bool b {false};
+            iterator it = find(key);
+            if (it == this->end())
+            {
+                this->push(make_pair(key, t));
+                b = true;
+                it = this->end() - 1;
+            }
+            return {it, b};
+        }
+
+        pair<iterator, bool> insert(const pair<Key, T>& p)
+        {
+            bool b {false};
+            const_iterator it = find(p.first);
+            if (it == this->end())
+            {
+                this->push(p);
+                b = true;
+                it = this->end() - 1;
+            }
+            return {(iterator)it, b};
+        }
+
+        pair<iterator, bool> emplace(const Key& key, const T& t)
+        {
+            return insert(key, t);
+        }
+
+        pair<iterator, bool> emplace(const pair<Key, T>& p)
+        {
+            return insert(p);
+        }
+
+        const T& at(const Key& key) const
+        {
+            // iterator it = find(key);
+            // if (it != this->end()) return it->second;
+            // return T();
+            return find(key)->second;
+        }
+
+        T& at(const Key& key)
+        {
+            // iterator it = find(key);
+            // if (it != this->end()) return it->second;
+            // return T();
+            return find(key)->second;
+        }
+
+        iterator erase(const iterator it)
+        {
+            iterator i = (iterator)find(it->first);
+            if (i != this->end())
+            {
+                return this->erase(i);
+            }
+            return this->end();
+        }
+
+        iterator erase(const size_t index)
+        {
+            if (index < this->size())
+            {
+                iterator it = this->begin() + index;
+                return this->erase(it);
+            }
+            return this->end();
+        }
+
+        const T& operator[] (const Key& key)
+        {
+            const_iterator it = find(key);
+            if (it != this->end()) return it->second;
+
+            insert(::arx::make_pair(key, T()));
+            return this->back().second;
+        }
+
+    private:
+
+        using RingBuffer<pair<Key, T>, N>::capacity;
+        using RingBuffer<pair<Key, T>, N>::data;
+        using RingBuffer<pair<Key, T>, N>::pop;
+        using RingBuffer<pair<Key, T>, N>::pop_front;
+        using RingBuffer<pair<Key, T>, N>::pop_back;
+        using RingBuffer<pair<Key, T>, N>::push;
+        using RingBuffer<pair<Key, T>, N>::push_back;
+        using RingBuffer<pair<Key, T>, N>::push_front;
+        using RingBuffer<pair<Key, T>, N>::emplace_back;
+        using RingBuffer<pair<Key, T>, N>::front;
+        using RingBuffer<pair<Key, T>, N>::back;
+        using RingBuffer<pair<Key, T>, N>::resize;
+        using RingBuffer<pair<Key, T>, N>::assign;
+        using RingBuffer<pair<Key, T>, N>::shrink_to_fit;
+    };
+
+} // namespace arx
+
+template<typename T, size_t N>
+using ArxRingBuffer = arx::RingBuffer<T, N>;
+
+
+#endif // ARX_CONTAINER_DISABLED
+#endif // ARX_RINGBUFFER_H
diff --git a/Tween/util/ArxContainer/LICENSE b/Tween/util/ArxContainer/LICENSE
new file mode 100644
index 0000000..8c86460
--- /dev/null
+++ b/Tween/util/ArxContainer/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Hideaki Tai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/Tween/util/ArxContainer/README.md b/Tween/util/ArxContainer/README.md
new file mode 100644
index 0000000..478a147
--- /dev/null
+++ b/Tween/util/ArxContainer/README.md
@@ -0,0 +1,166 @@
+# ArxContainer
+
+C++ container-like classes (vector, map, etc.) for Arduino which cannot use STL
+
+## Note
+
+`ArxContainer` is C++ container-__like__ classes for Arduino.
+All of the functions is not supported currently.
+Detail of these containers are described in Detail section.
+
+## Supported Container Types
+
+- `vector`
+- `map` (`pair`)
+- `deque`
+
+
+## Supported Boards
+
+This library is currently enabled only if you use following architecture.
+Please use C++ Standard Template Library for other boards.
+
+- AVR (Uno, Nano, Mega, etc.)
+- MEGAAVR (Uno WiFi, Nano Ecery, etc.)
+- SAMD (Zero, MKR, M0, etc.)
+- SPRESENSE
+
+
+## Usage
+
+### vector
+
+```C++
+// initialize with initializer_list
+arx::vector<int> vs {1, 2, 3};
+
+// add contents
+for (size_t i = 4; i <= 5; ++i)
+    vs.push_back(i);
+
+// index access
+for (size_t i = 0; i < vs.size(); ++i)
+    Serial.println(vs[i]);
+
+// range-based access
+for (const auto& v : vs)
+    Serial.println(v);
+```
+
+### map
+
+``` C++
+// initialize with initializer_list
+arx::map<String, int> mp {{"one", 1}, {"two", 2}};
+
+// add contents
+mp.insert("three", 3);
+mp["four"] = 4;
+
+// range based access
+for (const auto& m : mp)
+{
+    Serial.print("{");
+    Serial.print(m.first); Serial.print(",");
+    Serial.print(m.second);
+    Serial.println("}");
+}
+
+// key access
+Serial.print("one   = "); Serial.println(mp["one"]);
+Serial.print("two   = "); Serial.println(mp["two"]);
+Serial.print("three = "); Serial.println(mp["three"]);
+Serial.print("four  = "); Serial.println(mp["four"]);
+```
+
+### deque
+
+```C++
+// initialize with initializer_list
+arx::deque<int> dq {1, 2, 3};
+
+// add contents
+for (int i = 4; i <= 5; ++i)
+    dq.push_back(i);
+
+// index access
+for (int i = 0; i < dq.size(); ++i)
+    Serial.print(dq[i]);
+```
+
+
+## Detail
+
+`ArxContainer` is C++ container-__like__ classes for Arduino.
+This library is based on `arx::RingBuffer` and `arx::xxxx` is limited-size container.
+`arx::RingBuffer` can be used as:
+
+```C++
+ArxRingBuffer<uint8_t, 4> buffer;
+
+buffer.push(1);
+buffer.push(2);
+buffer.push(3);
+
+for(size_t i = 0; i < buffer.size(); ++i)
+    Serial.println(buffer[i]);
+
+buffer.pop();
+
+for(auto& b : buffer)
+    Serial.println(b);
+```
+
+`arx::xxxx` are derived from `RingBuffer` and defined as:
+
+``` C++
+namespace arx {
+    template <typename T, size_t N = ARX_VECTOR_DEFAULT_SIZE>
+    struct vector : public RingBuffer<T, N>
+
+    template <class Key, class T, size_t N = ARX_MAP_DEFAULT_SIZE>
+    struct map : public RingBuffer<pair<Key, T>, N>
+
+    template <typename T, size_t N = ARX_DEQUE_DEFAULT_SIZE>
+    struct deque : public RingBuffer<T, N>
+}
+```
+
+So range-based loop cannot be applyed to `arx::deque` (iterator is not continuous because it is based on `RingBuffer`).
+
+
+### Manage Size Limit of Container
+
+Global default size of container can be changed by defining these macros before `#include <ArxContainer.h>`.
+
+``` C++
+#define ARX_VECTOR_DEFAULT_SIZE XX // default: 16
+#define ARX_MAP_DEFAULT_SIZE XX    // default: 16
+#define ARX_DEQUE_DEFAULT_SIZE XX  // default: 16
+```
+
+Or you can change each container size by template argument.
+
+``` C++
+arx::vector<int, 3> vs;
+arx::map<String, int, 4> ms;
+arx::deque<int, 5> ds;
+```
+
+## Roadmap
+
+This library will be updated if I want to use more container interfaces on supported boards shown above.
+PRs are welcome!
+
+
+## Used Inside of
+
+- [Packetizer](https://github.com/hideakitai/Packetizer)
+- [MsgPack](https://github.com/hideakitai/MsgPack)
+- [MsgPacketizer](https://github.com/hideakitai/MsgPacketizer)
+- [ArduinoOSC](https://github.com/hideakitai/ArduinoOSC)
+
+
+## License
+
+MIT
diff --git a/Tween/util/ArxContainer/library.json b/Tween/util/ArxContainer/library.json
new file mode 100644
index 0000000..1ddeef3
--- /dev/null
+++ b/Tween/util/ArxContainer/library.json
@@ -0,0 +1,20 @@
+{
+    "name": "ArxContainer",
+    "keywords": "ringbuffer, vector, deque, map",
+    "description": "C++ container-like classes (vector, map, etc.) for Arduino which cannot use STL",
+    "repository":
+    {
+        "type": "git",
+        "url": "https://github.com/hideakitai/ArxContainer.git"
+    },
+    "authors":
+    {
+        "name": "Hideaki Tai",
+        "url": "https://github.com/hideakitai",
+        "maintainer": true
+    },
+    "version": "0.3.6",
+    "license": "MIT",
+    "frameworks": "arduino",
+    "platforms": "*"
+}
diff --git a/Tween/util/ArxContainer/library.properties b/Tween/util/ArxContainer/library.properties
new file mode 100644
index 0000000..cfa6d96
--- /dev/null
+++ b/Tween/util/ArxContainer/library.properties
@@ -0,0 +1,9 @@
+name=ArxContainer
+version=0.3.6
+author=hideakitai
+maintainer=hideakitai
+sentence=C++ container-like classes (vector, map, etc.) for Arduino which cannot use STL
+paragraph=C++ container-like classes (vector, map, etc.) for Arduino which cannot use STL
+category=Data Storage
+url=https://github.com/hideakitai
+architectures=*
diff --git a/Tween/util/ArxSmartPtr/ArxSmartPtr.h b/Tween/util/ArxSmartPtr/ArxSmartPtr.h
new file mode 100644
index 0000000..a2c163b
--- /dev/null
+++ b/Tween/util/ArxSmartPtr/ArxSmartPtr.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#ifndef ARX_SMART_PTR_H
+#define ARX_SMART_PTR_H
+
+#include <Arduino.h>
+
+#if defined(ARDUINO_ARCH_AVR)\
+ || defined(ARDUINO_ARCH_MEGAAVR)\
+ || defined(ARDUINO_ARCH_SAMD)\
+ || defined(ARDUINO_spresense_ast)
+    #define ARX_SMART_PTR_DISABLED
+#endif
+
+#ifdef ARX_SMART_PTR_DISABLED
+    #include "ArxSmartPtr/shared_ptr.h"
+#endif
+
+#endif // ARX_SMART_PTR_H
diff --git a/Tween/util/ArxSmartPtr/ArxSmartPtr/LICENSE_1_0.txt b/Tween/util/ArxSmartPtr/ArxSmartPtr/LICENSE_1_0.txt
new file mode 100644
index 0000000..127a5bc
--- /dev/null
+++ b/Tween/util/ArxSmartPtr/ArxSmartPtr/LICENSE_1_0.txt
@@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
\ No newline at end of file
diff --git a/Tween/util/ArxSmartPtr/ArxSmartPtr/detail/shared_count.h b/Tween/util/ArxSmartPtr/ArxSmartPtr/detail/shared_count.h
new file mode 100644
index 0000000..4122cfa
--- /dev/null
+++ b/Tween/util/ArxSmartPtr/ArxSmartPtr/detail/shared_count.h
@@ -0,0 +1,157 @@
+#pragma once
+
+#ifndef ARX_SMART_PTR_DETAIL_SHARED_COUNT_H
+#define ARX_SMART_PTR_DETAIL_SHARED_COUNT_H
+
+#include <Arduino.h>
+
+// imported and simplified from https://github.com/boostorg/smart_ptr
+
+namespace arx
+{
+    namespace detail
+    {
+        class sp_counted_base
+        {
+            sp_counted_base(const sp_counted_base&) = delete;
+            sp_counted_base& operator= (const sp_counted_base&) = delete;
+
+            int use_count_;
+
+        public:
+
+            sp_counted_base() : use_count_(1) {}
+            virtual ~sp_counted_base() {}
+
+            virtual void dispose() = 0;
+
+            void add_ref()
+            {
+                ++use_count_;
+            }
+
+            void release()
+            {
+                if (--use_count_ == 0)
+                    dispose();
+            }
+
+            long use_count() const
+            {
+                return static_cast<int const volatile &>(use_count_);
+            }
+        };
+
+
+        template <typename T>
+        class sp_counted_impl : public sp_counted_base
+        {
+            T* ptr;
+
+            sp_counted_impl(const sp_counted_impl&) = delete;
+            sp_counted_impl& operator= (const sp_counted_impl&) = delete;
+
+            typedef sp_counted_impl<T> this_type;
+
+        public:
+
+            sp_counted_impl(T* ptr) : ptr(ptr) {}
+            virtual ~sp_counted_impl() {}
+
+            virtual void dispose() override
+            {
+                delete ptr;
+            }
+        };
+
+
+
+        class shared_count
+        {
+        private:
+
+            sp_counted_base* pi_;
+
+        public:
+
+            shared_count() : pi_(0)
+            {
+            }
+
+            explicit shared_count(sp_counted_base* p) : pi_(p)
+            {
+            }
+
+            template<class Y>
+            explicit shared_count(Y* p) : pi_(0)
+            {
+                pi_ = new sp_counted_impl<Y>(p);
+
+                if(pi_ == 0)
+                {
+                    delete p;
+                }
+            }
+
+            ~shared_count()
+            {
+                if(pi_ != 0) pi_->release();
+            }
+
+            shared_count(const shared_count& r) : pi_(r.pi_)
+            {
+                if(pi_ != 0) pi_->add_ref();
+            }
+
+            shared_count(shared_count&& r) : pi_(r.pi_)
+            {
+                r.pi_ = 0;
+            }
+
+            shared_count& operator= (const shared_count& r)
+            {
+                sp_counted_base* tmp = r.pi_;
+                if(tmp != pi_)
+                {
+                    if(tmp != 0) tmp->add_ref();
+                    if(pi_ != 0) pi_->release();
+                    pi_ = tmp;
+                }
+                return *this;
+            }
+
+            void swap(shared_count& r)
+            {
+                sp_counted_base* tmp = r.pi_;
+                r.pi_ = pi_;
+                pi_ = tmp;
+            }
+
+            long use_count() const
+            {
+                return (pi_ != 0) ? pi_->use_count() : 0;
+            }
+
+            bool unique() const
+            {
+                return use_count() == 1;
+            }
+
+            bool empty() const
+            {
+                return pi_ == 0;
+            }
+
+            friend inline bool operator== (const shared_count& a, const shared_count& b)
+            {
+                return a.pi_ == b.pi_;
+            }
+        };
+
+    } // namespace detail
+
+} // namespace arx
+
+
+
+#endif // ARX_SMART_PTR_DETAIL_SHARED_COUNT_H
diff --git a/Tween/util/ArxSmartPtr/ArxSmartPtr/shared_ptr.h b/Tween/util/ArxSmartPtr/ArxSmartPtr/shared_ptr.h
new file mode 100644
index 0000000..25a3bea
--- /dev/null
+++ b/Tween/util/ArxSmartPtr/ArxSmartPtr/shared_ptr.h
@@ -0,0 +1,375 @@
+#pragma once
+
+#ifndef ARX_SMART_PTR_SHARED_PTR_H
+#define ARX_SMART_PTR_SHARED_PTR_H
+
+#include <Arduino.h>
+#include "detail/shared_count.h"
+
+// imported and simplified from https://github.com/boostorg/smart_ptr
+
+namespace arx {
+
+    template<class T> class shared_ptr;
+
+    namespace sp
+    {
+        namespace detail
+        {
+            typedef decltype(nullptr) nullptr_t;
+
+            template<class T> T&& move(T& t) { return static_cast<T&&>(t); }
+
+            template<class T> T forward(T t) { return t; }
+
+            template <class T>
+            void swap(T& a, T& b)
+            {
+                T t = move(a);
+                a = move(b);
+                b = move(t);
+            }
+        }
+
+        // element, element_type
+
+        template<class T> struct element { typedef T type; };
+        template<class T> struct element<T[]> { typedef T type; };
+        template<class T, size_t N> struct element<T[N]> { typedef T type; };
+
+        // dereference, return type of operator*
+
+        template<class T> struct dereference { typedef T& type; };
+        template<> struct dereference<void> { typedef void type; };
+        template<> struct dereference<void const> { typedef void type; };
+        template<> struct dereference<void volatile> { typedef void type; };
+        template<> struct dereference<void const volatile> { typedef void type; };
+        template<class T> struct dereference<T[]> { typedef void type; };
+        template<class T, size_t N> struct dereference<T[N]> { typedef void type; };
+
+        // member_access, return type of operator->
+
+        template<class T> struct member_access { typedef T* type; };
+        template<class T> struct member_access<T[]> { typedef void type; };
+        template<class T, size_t N> struct member_access<T[N]> { typedef void type; };
+
+        // array_access, return type of operator[]
+
+        template<class T> struct array_access { typedef void type; };
+        template<class T> struct array_access<T[]> { typedef T& type; };
+        template<class T, size_t N> struct array_access<T[N]> { typedef T& type; };
+    }
+
+
+    template<class T> class shared_ptr
+    {
+    public:
+
+        typedef typename sp::element<T>::type element_type;
+
+    private:
+
+        typedef shared_ptr<T> this_type;
+
+        template<class Y> friend class shared_ptr;
+
+        element_type* px;
+        detail::shared_count pn;
+
+    public:
+
+        shared_ptr() : px(0), pn()
+        {
+        }
+
+        shared_ptr(sp::detail::nullptr_t) : px(0), pn()
+        {
+        }
+
+        template<class Y>
+        explicit shared_ptr(Y* p): px(p), pn()
+        {
+            detail::shared_count(p).swap(pn);
+        }
+
+        shared_ptr(const shared_ptr& r) : px(r.px), pn(r.pn)
+        {
+        }
+
+        template<class Y>
+        shared_ptr(const shared_ptr<Y>& r)
+        : px(r.px), pn(r.pn)
+        {
+        }
+
+        template<class Y>
+        shared_ptr(const shared_ptr<Y>& r, element_type* p) : px(p), pn(r.pn)
+        {
+        }
+
+        shared_ptr& operator= (const shared_ptr& r)
+        {
+            this_type(r).swap(*this);
+            return *this;
+        }
+
+        template<class Y>
+        shared_ptr& operator= (const shared_ptr<Y>& r)
+        {
+            this_type(r).swap(*this);
+            return *this;
+        }
+
+        shared_ptr(shared_ptr&& r) : px(r.px), pn()
+        {
+            pn.swap(r.pn);
+            r.px = 0;
+        }
+
+        template<class Y>
+        shared_ptr(shared_ptr<Y>&& r)
+        : px(r.px), pn()
+        {
+            pn.swap( r.pn );
+            r.px = 0;
+        }
+
+        shared_ptr& operator= (shared_ptr&& r)
+        {
+            this_type(static_cast<shared_ptr&&>(r)).swap(*this);
+            return *this;
+        }
+
+        template<class Y>
+        shared_ptr & operator= (shared_ptr<Y>&& r)
+        {
+            this_type(static_cast<shared_ptr<Y>&&>(r)).swap(*this);
+            return *this;
+        }
+
+        template<class Y>
+        shared_ptr(shared_ptr<Y>&& r, element_type* p) : px(p), pn()
+        {
+            pn.swap( r.pn );
+            r.px = 0;
+        }
+
+        shared_ptr& operator= (sp::detail::nullptr_t)
+        {
+            this_type().swap(*this);
+            return *this;
+        }
+
+        void reset()
+        {
+            this_type().swap(*this);
+        }
+
+        template<class Y>
+        void reset(Y* p)
+        {
+            this_type(p).swap(*this);
+        }
+
+        template<class Y>
+        void reset(const shared_ptr<Y>& r, element_type* p)
+        {
+            this_type(r, p).swap(*this);
+        }
+
+        template<class Y>
+        void reset(shared_ptr<Y>&& r, element_type* p)
+        {
+            this_type(static_cast<shared_ptr<Y>&&>(r), p).swap(*this);
+        }
+
+        typename sp::dereference<T>::type operator* () const
+        {
+            return *px;
+        }
+
+        typename sp::member_access<T>::type operator-> () const
+        {
+            return px;
+        }
+
+        typename sp::array_access<T>::type operator[] (size_t i) const
+        {
+            return static_cast<typename sp::array_access<T>::type>(px[i]);
+        }
+
+        element_type* get() const
+        {
+            return px;
+        }
+
+        explicit operator bool () const
+        {
+            return px != 0;
+        }
+
+        bool operator! () const
+        {
+            return px == 0;
+        }
+
+        bool unique() const
+        {
+            return pn.unique();
+        }
+
+        long use_count() const
+        {
+            return pn.use_count();
+        }
+
+        void swap(shared_ptr& other)
+        {
+            sp::detail::swap(px, other.px);
+            pn.swap(other.pn);
+        }
+
+    };  // shared_ptr
+
+
+
+    template<class T, class U>
+    inline bool operator== (const shared_ptr<T>& a, const shared_ptr<U>& b)
+    {
+        return a.get() == b.get();
+    }
+
+    template<class T, class U>
+    inline bool operator!= (const shared_ptr<T>& a, const shared_ptr<U>& b)
+    {
+        return a.get() != b.get();
+    }
+
+    template<class T>
+    inline bool operator== (const shared_ptr<T>& p, sp::detail::nullptr_t)
+    {
+        return p.get() == 0;
+    }
+
+    template<class T>
+    inline bool operator== (sp::detail::nullptr_t, const shared_ptr<T>& p )
+    {
+        return p.get() == 0;
+    }
+
+    template<class T>
+    inline bool operator!= (const shared_ptr<T>& p, sp::detail::nullptr_t)
+    {
+        return p.get() != 0;
+    }
+
+    template<class T>
+    inline bool operator!= (sp::detail::nullptr_t, const shared_ptr<T>& p )
+    {
+        return p.get() != 0;
+    }
+
+    template<class T>
+    inline void swap(const shared_ptr<T>& a, const shared_ptr<T>& b)
+    {
+        a.swap(b);
+    }
+
+    template<class T, class U>
+    shared_ptr<T> static_pointer_cast(const shared_ptr<U>& r)
+    {
+        (void)static_cast<T*>(static_cast<U*>(0));
+
+        typedef typename shared_ptr<T>::element_type E;
+        E* p = static_cast<E*>(r.get());
+        return shared_ptr<T>(r, p);
+    }
+
+    template<class T, class U>
+    shared_ptr<T> const_pointer_cast(const shared_ptr<U>& r)
+    {
+        (void)const_cast<T*>(static_cast<U*>(0));
+
+        typedef typename shared_ptr<T>::element_type E;
+        E* p = const_cast<E*>(r.get());
+        return shared_ptr<T>(r, p);
+    }
+
+    template<class T, class U>
+    shared_ptr<T> dynamic_pointer_cast(const shared_ptr<U>& r)
+    {
+        (void)dynamic_cast<T*>(static_cast<U*>(0));
+
+        typedef typename shared_ptr<T>::element_type E;
+        E* p = dynamic_cast<E*>(r.get());
+        return p ? shared_ptr<T>(r, p): shared_ptr<T>();
+    }
+
+    template<class T, class U>
+    shared_ptr<T> reinterpret_pointer_cast(const shared_ptr<U>& r)
+    {
+        (void)reinterpret_cast<T*>(static_cast<U*>(0) );
+
+        typedef typename shared_ptr<T>::element_type E;
+        E* p = reinterpret_cast<E*>(r.get());
+        return shared_ptr<T>(r, p);
+    }
+
+    template<class T, class U>
+    shared_ptr<T> static_pointer_cast(shared_ptr<U>&& r)
+    {
+        (void)static_cast<T*>(static_cast<U*>(0));
+
+        typedef typename shared_ptr<T>::element_type E;
+        E* p = static_cast<E*>(r.get());
+        return shared_ptr<T>(sp::detail::move(r), p);
+    }
+
+    template<class T, class U>
+    shared_ptr<T> const_pointer_cast(shared_ptr<U>&& r)
+    {
+        (void)const_cast<T*>(static_cast<U*>(0));
+
+        typedef typename shared_ptr<T>::element_type E;
+        E* p = const_cast<E*>(r.get());
+        return shared_ptr<T>(sp::detail::move(r), p);
+    }
+
+    template<class T, class U>
+    shared_ptr<T> dynamic_pointer_cast(shared_ptr<U>&& r)
+    {
+        (void)dynamic_cast<T*>(static_cast<U*>(0));
+
+        typedef typename shared_ptr<T>::element_type E;
+        E* p = dynamic_cast<E*>(r.get());
+        return p ? shared_ptr<T>(sp::detail::move(r), p) : shared_ptr<T>();
+    }
+
+    template<class T, class U>
+    shared_ptr<T> reinterpret_pointer_cast(shared_ptr<U>&& r)
+    {
+        (void)reinterpret_cast<T*>(static_cast<U*>(0));
+
+        typedef typename shared_ptr<T>::element_type E;
+        E* p = reinterpret_cast<E*>(r.get());
+        return shared_ptr<T>(sp::detail::move(r), p);
+    }
+
+
+    // make_shared : for compatibility, just an alias of constructor
+
+    template<class T>
+    shared_ptr<T> make_shared()
+    {
+        return shared_ptr<T>(new T);
+    }
+
+    template<class T, class... Args>
+    shared_ptr<T> make_shared(Args&&... args)
+    {
+        return shared_ptr<T>(new T(sp::detail::forward<Args>(args)...));
+    }
+
+} // arx
+
+#endif // ARX_SMART_PTR_SHARED_PTR_H
diff --git a/Tween/util/ArxSmartPtr/LICENSE b/Tween/util/ArxSmartPtr/LICENSE
new file mode 100644
index 0000000..6f5269b
--- /dev/null
+++ b/Tween/util/ArxSmartPtr/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Hideaki Tai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/Tween/util/ArxSmartPtr/README.md b/Tween/util/ArxSmartPtr/README.md
new file mode 100644
index 0000000..24bd3ae
--- /dev/null
+++ b/Tween/util/ArxSmartPtr/README.md
@@ -0,0 +1,77 @@
+# ArxSmartPtr
+
+C++ smart pointer-like classes for Arduino which can't use standard smart pointers
+
+
+## Note
+
+`ArxSmartPtr` is C++ smart pointer-__like__ classes for Arduino.
+All of the functions is not supported currently.
+Almost all functions are imported and simplified based on [Boost.SmartPtr](https://github.com/boostorg/smart_ptr).
+
+
+## Supported SmartPtr
+
+- `shared_ptr`
+
+
+### Limitations
+
+- Custom Deleter cannot be used
+- Custom Allocater cannot be used
+- `make_shared` is just an alias for constructor
+- namespace `arx` is used instead of `std`
+
+
+## Supported Boards
+
+This library is currently enabled only if you use following architecture.
+Please use C++ Standard Template Library for other boards.
+
+- AVR (Uno, Nano, Mega, etc.)
+- MEGAAVR (Uno WiFi, Nano Ecery, etc.)
+- SAMD (Zero, MKR, M0, etc.)
+- SPRESENSE
+
+
+## Usage
+
+Please see example for more information.
+
+``` C++
+{
+    Serial.println("start");
+    arx::shared_ptr<Base> t1(new Base(4));
+    arx::shared_ptr<Base> t2;
+    {
+        arx::shared_ptr<Base> t3(new Base(5));
+        arx::shared_ptr<Base> t4(new Base(6));
+        t2 = t3;
+    }
+    Serial.println("end");
+}
+// start
+// Base::Constructor 4
+// Base::Constructor 5
+// Base::Constructor 6
+// Base::Destructor 6
+// end
+// Base::Destructor 5
+// Base::Destructor 4
+```
+
+## Used Inside of
+
+- [Packetizer](https://github.com/hideakitai/Packetizer)
+- [MsgPacketizer](https://github.com/hideakitai/MsgPacketizer)
+- [ArduinoOSC](https://github.com/hideakitai/ArduinoOSC)
+
+
+## Roadmap
+
+This library will be updated if I want to use more smart pointer interfaces on supported boards shown above.
+PRs are welcome!
+
+## License
+
+MIT
diff --git a/Tween/util/ArxSmartPtr/library.json b/Tween/util/ArxSmartPtr/library.json
new file mode 100644
index 0000000..461f97b
--- /dev/null
+++ b/Tween/util/ArxSmartPtr/library.json
@@ -0,0 +1,20 @@
+{
+    "name": "ArxSmartPtr",
+    "keywords": "smart ptr, shared ptr, stl",
+    "description": "C++ smart pointer-like classes for Arduino which cannot use standard smart pointers",
+    "repository":
+    {
+        "type": "git",
+        "url": "https://github.com/hideakitai/ArxSmartPtr.git"
+    },
+    "authors":
+    {
+        "name": "Hideaki Tai",
+        "url": "https://github.com/hideakitai",
+        "maintainer": true
+    },
+    "version": "0.1.1",
+    "license": "MIT",
+    "frameworks": "arduino",
+    "platforms": "*"
+}
diff --git a/Tween/util/ArxSmartPtr/library.properties b/Tween/util/ArxSmartPtr/library.properties
new file mode 100644
index 0000000..030b4a4
--- /dev/null
+++ b/Tween/util/ArxSmartPtr/library.properties
@@ -0,0 +1,9 @@
+name=ArxSmartPtr
+version=0.1.1
+author=hideakitai
+maintainer=hideakitai
+sentence=C++ smart pointer-like classes for Arduino which cannot use standard smart pointers
+paragraph=C++ smart pointer-like classes for Arduino which cannot use standard smart pointers
+category=Data Storage
+url=https://github.com/hideakitai
+architectures=*
diff --git a/Tween/util/ArxTypeTraits/ArxTypeTraits.h b/Tween/util/ArxTypeTraits/ArxTypeTraits.h
new file mode 100644
index 0000000..717cd52
--- /dev/null
+++ b/Tween/util/ArxTypeTraits/ArxTypeTraits.h
@@ -0,0 +1,27 @@
+#pragma once
+
+#ifndef ARX_TYPE_TRAITS_H
+#define ARX_TYPE_TRAITS_H
+
+#if defined(ARDUINO_ARCH_AVR)\
+ || defined(ARDUINO_ARCH_MEGAAVR)\
+ || defined(ARDUINO_ARCH_SAMD)\
+ || defined(ARDUINO_spresense_ast)
+    #define ARX_TYPE_TRAITS_DISABLED
+    #if defined(ARDUINO_ARCH_MEGAAVR)\
+    || defined(ARDUINO_ARCH_SAMD)\
+    || defined(ARDUINO_spresense_ast)
+        #define ARX_TYPE_TRAITS_NEW_DISABLED
+    #endif
+#endif
+
+#include <stddef.h>
+#ifndef ARX_TYPE_TRAITS_DISABLED
+    #include <type_traits>
+    #include <tuple>
+    #include <functional>
+#endif
+
+#include "ArxTypeTraits/type_traits.h"
+
+#endif // ARX_TYPE_TRAITS_H
diff --git a/Tween/util/ArxTypeTraits/ArxTypeTraits/functional.h b/Tween/util/ArxTypeTraits/ArxTypeTraits/functional.h
new file mode 100644
index 0000000..ed1ff17
--- /dev/null
+++ b/Tween/util/ArxTypeTraits/ArxTypeTraits/functional.h
@@ -0,0 +1,149 @@
+#pragma once
+
+#ifndef ARX_TYPE_TRAITS_FUNCTIONAL_H
+#define ARX_TYPE_TRAITS_FUNCTIONAL_H
+
+#include <Arduino.h>
+
+#ifdef ARX_TYPE_TRAITS_NEW_DISABLED
+    void* operator new (const size_t size, void* ptr) { (void)size; return ptr; }
+#else
+    #include <new.h>
+#endif
+
+#ifdef ARX_TYPE_TRAITS_DISABLED
+
+namespace std {
+
+    // reference:
+    // stack overflow https://stackoverflow.com/questions/32074410/stdfunction-bind-like-type-erasure-without-standard-c-library
+
+    template<class Signature>
+    struct function;
+
+    template<class R, class... Args>
+    class function<R(Args...)>
+    {
+        struct vtable_t
+        {
+            void (*mover)(void* src, void* dest);
+            void (*destroyer)(void*);
+            R (*invoke)(void const* t, Args&&... args);
+
+            template <class T>
+            static vtable_t const* get()
+            {
+                static const vtable_t table =
+                {
+                    // mover
+                    [] (void* src, void* dest)
+                    {
+                        new(dest) T(move(*static_cast<T*>(src)));
+                    },
+                    // destroyer
+                    [] (void* t)
+                    {
+                        static_cast<T*>(t)->~T();
+                    },
+                    // invoke
+                    [] (void const* t, Args&&... args) -> R
+                    {
+                        return (*static_cast<T const*>(t))(std::forward<Args>(args)...);
+                    }
+                };
+                return &table;
+            }
+        };
+
+        vtable_t const* table {nullptr};
+        void* data {nullptr};
+
+    public:
+
+        template <
+            class Func,
+            class dF = typename std::decay<Func>::type,
+            typename enable_if <!std::is_same<dF, function>{}>::type* = nullptr,
+            typename enable_if <std::is_convertible<typename result_of<dF&(Args...)>::type, R>{}>::type* = nullptr
+        >
+        function(const Func& f)
+        : table(vtable_t::template get<dF>())
+        {
+            data = reinterpret_cast<void*>(new Func(f));
+        }
+        function(const function& o)
+        : table(o.table)
+        {
+            data = o.data;
+        }
+        function(function&& o)
+        : table(o.table)
+        {
+            if (table) table->mover(o.data, data);
+        }
+        function()
+        {
+        }
+        ~function()
+        {
+            if (table) table->destroyer(data);
+        }
+
+        function& operator= (const function& o)
+        {
+            this->~function();
+            new(this) function(move(o));
+            return *this;
+        }
+        function& operator= (function&& o)
+        {
+            this->~function();
+            new(this) function(move(o));
+            return *this;
+        }
+        function& operator= (std::nullptr_t p)
+        {
+            (void)p;
+            this->~function();
+            return *this;
+        }
+
+        explicit operator bool() const
+        {
+            return table;
+        }
+
+        R operator()(Args...args) const
+        {
+            return table->invoke(data, forward<Args>(args)...);
+        }
+    };
+
+    template<class R, class... Args>
+    inline bool operator== (const function<R(Args...)>& f, std::nullptr_t)
+    {
+        return !static_cast<bool>(f);
+    }
+
+    template<class R, class... Args>
+    inline bool operator== (std::nullptr_t, const function<R(Args...)>& f)
+    {
+        return !static_cast<bool>(f);
+    }
+
+    template<class R, class... Args>
+    inline bool operator!= (const function<R(Args...)>& f, std::nullptr_t)
+    {
+        return static_cast<bool>(f);
+    }
+
+    template<class R, class... Args>
+    inline bool operator!= (std::nullptr_t, const function<R(Args...)>& f)
+    {
+        return static_cast<bool>(f);
+    }
+
+} // namespace std
+
+#endif // ARX_TYPE_TRAITS_DISABLED
+#endif // ARX_TYPE_TRAITS_FUNCTIONAL_H
diff --git a/Tween/util/ArxTypeTraits/ArxTypeTraits/tuple.h b/Tween/util/ArxTypeTraits/ArxTypeTraits/tuple.h
new file mode 100644
index 0000000..f8d765b
--- /dev/null
+++ b/Tween/util/ArxTypeTraits/ArxTypeTraits/tuple.h
@@ -0,0 +1,77 @@
+#pragma once
+
+#ifndef ARX_TYPE_TRAITS_TUPLE_H
+#define ARX_TYPE_TRAITS_TUPLE_H
+
+#ifdef ARX_TYPE_TRAITS_DISABLED
+
+namespace std {
+
+    // https://theolizer.com/cpp-school2/cpp-school2-15/
+    // https://wandbox.org/permlink/C0BWIzjqg4iO3kKZ
+
+    template<typename... Ts>
+    struct tuple
+    {
+        tuple() {}
+    };
+
+    template<typename tFirst, typename... tRest>
+    class tuple<tFirst, tRest...> : public tuple<tRest...>
+    {
+        template<size_t N, typename... tTypes> friend struct get_helper;
+        tFirst  mMember;
+    public:
+        tuple(tFirst const& iFirst, tRest const&... iRest)
+        : tuple<tRest...>(iRest...)
+        , mMember(iFirst)
+        { }
+        constexpr tuple() {}
+    };
+
+    template<size_t N, typename... tTypes>
+    struct get_helper { };
+    template<typename tFirst, typename... tRest>
+    struct get_helper<0, tFirst, tRest...>
+    {
+        typedef tFirst type;
+        static type& get(tuple<tFirst, tRest...>& iTuple)
+        {
+            return iTuple.mMember;
+        }
+    };
+    template<size_t N, typename tFirst, typename... tRest>
+    struct get_helper<N, tFirst, tRest...>
+    {
+        typedef typename get_helper<N - 1, tRest...>::type type;
+        static type& get(tuple<tFirst, tRest...>& iTuple)
+        {
+            return get_helper<N - 1, tRest...>::get(iTuple);
+        }
+    };
+
+    template<size_t N, typename... tTypes>
+    typename get_helper<N, tTypes...>::type& get(tuple<tTypes...>& iTuple)
+    {
+        return get_helper<N, tTypes...>::get(iTuple);
+    }
+
+    template <class T> class tuple_size;
+    template <class T> class tuple_size<const T>;
+    template <class T> class tuple_size<volatile T>;
+    template <class T> class tuple_size<const volatile T>;
+    template <class... Types>
+    class tuple_size <tuple<Types...>>
+    : public integral_constant <size_t, sizeof...(Types)> {};
+
+    template <class... Types>
+    auto make_tuple(Types&&... args)
+    -> std::tuple<typename std::remove_reference<Types>::type...>
+    {
+        return std::tuple<typename std::remove_reference<Types>::type...>(std::forward<typename std::remove_reference<Types>::type>(args)...);
+    }
+
+} // namespace std
+
+#endif // ARX_TYPE_TRAITS_DISABLED
+#endif // ARX_TYPE_TRAITS_TUPLE_H
diff --git a/Tween/util/ArxTypeTraits/ArxTypeTraits/type_traits.h b/Tween/util/ArxTypeTraits/ArxTypeTraits/type_traits.h
new file mode 100644
index 0000000..05784e3
--- /dev/null
+++ b/Tween/util/ArxTypeTraits/ArxTypeTraits/type_traits.h
@@ -0,0 +1,626 @@
+#pragma once
+
+#ifndef ARX_TYPE_TRAITS_TYPE_TRAITS_H
+#define ARX_TYPE_TRAITS_TYPE_TRAITS_H
+
+#ifdef ARX_TYPE_TRAITS_DISABLED
+
+#ifdef max
+    #undef max
+    template <typename T1, typename T2>
+    constexpr auto max(T1 x, T2 y)
+    -> decltype(x + y)
+    {
+        return (x > y) ? x : y;
+    }
+#endif
+#ifdef min
+    #undef min
+    template <typename T1, typename T2>
+    constexpr auto min(T1 x, T2 y)
+    -> decltype(x + y)
+    {
+        return (x < y) ? x : y;
+    }
+#endif
+
+#include <stddef.h>
+#include <float.h>
+#include <limits.h>
+
+namespace std {
+
+    using nullptr_t = decltype(nullptr);
+
+    // numeric_limits
+
+    template <typename T>
+    struct numeric_limits
+    {
+        static constexpr T max() { return T(); }
+        static constexpr T min() { return T(); }
+    };
+    template <> constexpr bool numeric_limits<bool>::max() { return true; }
+    template <> constexpr char numeric_limits<char>::max() { return CHAR_MAX; }
+    template <> constexpr signed char numeric_limits<signed char>::max() { return SCHAR_MAX; }
+    template <> constexpr unsigned char numeric_limits<unsigned char>::max() { return UCHAR_MAX; }
+    template <> constexpr wchar_t numeric_limits<wchar_t>::max() { return WCHAR_MAX; }
+    // template <> constexpr char8_t numeric_limits<char8_t>::max() { return UCHAR_MAX; }
+    template <> constexpr char16_t numeric_limits<char16_t>::max() { return UINT_LEAST16_MAX; }
+    template <> constexpr char32_t numeric_limits<char32_t>::max() { return UINT_LEAST32_MAX; }
+    template <> constexpr short numeric_limits<short>::max() { return SHRT_MAX; }
+    template <> constexpr unsigned short numeric_limits<unsigned short>::max() { return USHRT_MAX; }
+    template <> constexpr int numeric_limits<int>::max() { return INT_MAX; }
+    template <> constexpr unsigned int numeric_limits<unsigned int>::max() { return UINT_MAX; }
+    template <> constexpr long numeric_limits<long>::max() { return LONG_MAX; }
+    template <> constexpr unsigned long numeric_limits<unsigned long>::max() { return ULONG_MAX; }
+    // template <> constexpr long long numeric_limits<long long>::max() { return LLONG_MAX; }
+    // template <> constexpr unsigned long long numeric_limits<unsigned long long>::max() { return ULLONG_MAX; }
+    template <> constexpr float numeric_limits<float>::max() { return FLT_MAX; }
+    template <> constexpr double numeric_limits<double>::max() { return DBL_MAX; }
+    template <> constexpr long double numeric_limits<long double>::max() { return LDBL_MAX; }
+
+    template <> constexpr bool numeric_limits<bool>::min() { return false; }
+    template <> constexpr char numeric_limits<char>::min() { return CHAR_MIN; }
+    template <> constexpr signed char numeric_limits<signed char>::min() { return SCHAR_MIN; }
+    template <> constexpr unsigned char numeric_limits<unsigned char>::min() { return 0; }
+    template <> constexpr wchar_t numeric_limits<wchar_t>::min() { return WCHAR_MIN; }
+    // template <> constexpr char8_t numeric_limits<char8_t>::min() { return 0; }
+    template <> constexpr char16_t numeric_limits<char16_t>::min() { return 0; }
+    template <> constexpr char32_t numeric_limits<char32_t>::min() { return 0; }
+    template <> constexpr short numeric_limits<short>::min() { return SHRT_MIN; }
+    template <> constexpr unsigned short numeric_limits<unsigned short>::min() { return 0; }
+    template <> constexpr int numeric_limits<int>::min() { return INT_MIN; }
+    template <> constexpr unsigned int numeric_limits<unsigned int>::min() { return 0; }
+    template <> constexpr long numeric_limits<long>::min() { return LONG_MIN; }
+    template <> constexpr unsigned long numeric_limits<unsigned long>::min() { return 0; }
+    // template <> constexpr long long numeric_limits<long long>::min() { return LLONG_MIN; }
+    // template <> constexpr unsigned long long numeric_limits<unsigned long long>::min() { return 0; }
+    template <> constexpr float numeric_limits<float>::min() { return FLT_MIN; }
+    template <> constexpr double numeric_limits<double>::min() { return DBL_MIN; }
+    template <> constexpr long double numeric_limits<long double>::min() { return LDBL_MIN; }
+
+
+    // integral_constant
+
+    template<class T, T v>
+    struct integral_constant
+    {
+        static constexpr T value = v;
+        using value_type = T;
+        using type = integral_constant;
+        constexpr operator value_type() const noexcept { return value; }
+        constexpr value_type operator()() const noexcept { return value; }
+    };
+
+    using true_type = integral_constant<bool, true>;
+    using false_type = integral_constant<bool, false>;
+
+
+    template <class T>
+    T declval(); // no implementation
+
+
+    template <bool, typename T = void>
+    struct enable_if;
+    template <typename T>
+    struct enable_if <true, T> { using type = T; };
+
+
+    template<bool, class T, class F>
+    struct conditional { using type = T; };
+    template<class T, class F>
+    struct conditional<false, T, F> { using type = F; };
+
+
+    template <class T> struct remove_cv                   { using type = T; };
+    template <class T> struct remove_cv<const T>          { using type = T; };
+    template <class T> struct remove_cv<volatile T>       { using type = T; };
+    template <class T> struct remove_cv<const volatile T> { using type = T; };
+
+    template <class T> struct remove_const                { using type = T; };
+    template <class T> struct remove_const<const T>       { using type = T; };
+
+    template <class T> struct remove_volatile             { using type = T; };
+    template <class T> struct remove_volatile<volatile T> { using type = T; };
+
+    template <class T> struct remove_pointer                    { using type = T; };
+    template <class T> struct remove_pointer<T*>                { using type = T; };
+    template <class T> struct remove_pointer<T* const>          { using type = T; };
+    template <class T> struct remove_pointer<T* volatile>       { using type = T; };
+    template <class T> struct remove_pointer<T* const volatile> { using type = T; };
+
+    template <class T> struct remove_reference      { using type = T; };
+    template <class T> struct remove_reference<T&>  { using type = T; };
+    template <class T> struct remove_reference<T&&> { using type = T; };
+
+    template<class T> struct remove_extent                 { typedef T type; };
+    template<class T> struct remove_extent<T[]>            { typedef T type; };
+    template<class T, size_t N> struct remove_extent<T[N]> { typedef T type; };
+
+
+    template<class T>
+    T&& move(T& t){ return static_cast<T&&>(t); }
+    template<class T>
+    T&& move(T&& t){ return static_cast<T&&>(t); }
+
+
+    template <class T>
+    constexpr T&& forward(typename remove_reference<T>::type& t) noexcept
+    {
+        return static_cast<T&&>(t);
+    }
+    template <class T>
+    constexpr T&& forward(typename remove_reference<T>::type&& t) noexcept
+    {
+        return static_cast<T&&>(t);
+    }
+
+
+    namespace detail
+    {
+        template <class T>
+        struct type_identity { using type = T; };
+        template <class T>
+        auto try_add_pointer(int) -> type_identity<typename remove_reference<T>::type*>;
+        template <class T>
+        auto try_add_pointer(...) -> type_identity<T>;
+    }
+    template <class T>
+    struct add_pointer : decltype(detail::try_add_pointer<T>(0)) {};
+
+
+    template <typename T, typename U>
+    struct is_same : false_type {};
+    template <typename T>
+    struct is_same <T, T> : true_type {};
+
+
+    template <typename T>
+    struct is_integral : false_type {};
+    template <> struct is_integral <bool> : true_type {};
+    template <> struct is_integral <char> : true_type {};
+    template <> struct is_integral <signed char> : true_type {};
+    template <> struct is_integral <unsigned char> : true_type {};
+    template <> struct is_integral <char16_t> : true_type {};
+    template <> struct is_integral <char32_t> : true_type {};
+    template <> struct is_integral <wchar_t> : true_type {};
+    template <> struct is_integral <short> : true_type {};
+    template <> struct is_integral <unsigned short> : true_type {};
+    template <> struct is_integral <int> : true_type {};
+    template <> struct is_integral <unsigned> : true_type {};
+    template <> struct is_integral <long> : true_type {};
+    template <> struct is_integral <unsigned long> : true_type {};
+    template <> struct is_integral <long long> : true_type {};
+    template <> struct is_integral <unsigned long long> : true_type {};
+
+
+    template <typename T>
+    struct is_floating_point : false_type {};
+    template <> struct is_floating_point<float> : true_type {};
+    template <> struct is_floating_point<double> : true_type {};
+    template <> struct is_floating_point<long double> : true_type {};
+
+
+    template <typename T>
+    struct is_arithmetic
+    : conditional<
+        is_integral<T>::value || is_floating_point<T>::value,
+        true_type,
+        false_type
+    >::type
+    {};
+
+
+    namespace detail
+    {
+        template <typename T, bool = is_arithmetic<T>::value>
+        struct is_signed : integral_constant<bool, T(-1) < T(0)> {};
+        template <typename T>
+        struct is_signed<T, false> : false_type {};
+    }
+    template <typename T>
+    struct is_signed : detail::is_signed<T>::type {};
+
+
+    namespace detail
+    {
+        template<typename T, bool = is_arithmetic<T>::value>
+        struct is_unsigned : integral_constant<bool, T(0) < T(-1)> {};
+        template<typename T>
+        struct is_unsigned<T, false> : false_type {};
+    }
+    template<typename T>
+    struct is_unsigned : detail::is_unsigned<T>::type {};
+
+
+    template <class T> struct is_pointer_helper     : false_type {};
+    template <class T> struct is_pointer_helper<T*> : true_type {};
+    template <class T> struct is_pointer : is_pointer_helper<typename remove_cv<T>::type> {};
+
+
+    template<class T>
+    struct is_array : false_type {};
+    template<class T>
+    struct is_array<T[]> : true_type {};
+    template<class T, size_t N>
+    struct is_array<T[N]> : true_type {};
+
+
+    namespace details
+    {
+        template <class... Ts>
+        struct Tester { using type = void; };
+        template <class... Ts>
+        using void_t = typename Tester<Ts...>::type;
+        template<template<class...>class Z, class, class...Ts>
+        struct can_apply : false_type{};
+        template<template<class...>class Z, class...Ts>
+        struct can_apply<Z, void_t<Z<Ts...>>, Ts...> : true_type{};
+
+        template<class From, class To>
+        using try_convert = decltype(To{declval<From>()} );
+    }
+    template<template<class...>class Z, class...Ts>
+    using can_apply = details::can_apply<Z, void, Ts...>;
+    template<class From, class To>
+    struct is_convertible : can_apply <details::try_convert, From, To> {};
+    template<>
+    struct is_convertible<void,void> : true_type{};
+
+
+    // primary template
+    template<class>
+    struct is_function : false_type { };
+    // specialization for regular functions
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args...)> : true_type {};
+    // specialization for variadic functions such as std::printf
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args......)> : true_type {};
+    // specialization for function types that have cv-qualifiers
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args...) const> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args...) volatile> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args...) const volatile> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args......) const> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args......) volatile> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args......) const volatile> : true_type {};
+    // specialization for function types that have ref-qualifiers
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args...) &> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args...) const &> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args...) volatile &> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args...) const volatile &> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args......) &> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args......) const &> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args......) volatile &> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args......) const volatile &> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args...) &&> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args...) const &&> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args...) volatile &&> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args...) const volatile &&> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args......) &&> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args......) const &&> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args......) volatile &&> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args......) const volatile &&> : true_type {};
+
+
+    template<typename T>
+    struct is_empty : public integral_constant<bool, __is_empty(T)> { };
+
+
+    template <class T>
+    class decay
+    {
+        typedef typename remove_reference<T>::type U;
+    public:
+        typedef typename conditional<
+            is_array<U>::value,
+            typename remove_extent<U>::type*,
+            typename conditional<
+                is_function<U>::value,
+                typename add_pointer<U>::type,
+                typename remove_cv<U>::type
+            >::type
+        >::type type;
+    };
+
+
+    namespace details
+    {
+        template<class T> struct tag { using type=T; };
+        template<class Tag> using type_t = typename Tag::type;
+
+        template<class G, class...Args>
+        using invoke_t = decltype( declval<G>()(declval<Args>()...) );
+
+        template<class Sig, class = void>
+        struct result_of {};
+        template<class G, class...Args>
+        struct result_of<G(Args...), void_t<invoke_t<G, Args...>>>
+        : tag <invoke_t<G, Args...>>
+        {};
+    }
+    template<class Sig>
+    using result_of = details::result_of<Sig>;
+
+
+    template <class T>
+    void swap(T& a, T& b)
+    {
+        T t = move(a);
+        a = move(b);
+        b = move(t);
+    }
+
+
+#ifndef ARX_TYPE_TRAITS_INITIALIZER_LIST_DEFINED
+#define ARX_TYPE_TRAITS_INITIALIZER_LIST_DEFINED
+
+    template<class T>
+    class initializer_list
+    {
+    private:
+        const T* array;
+        size_t len;
+        initializer_list(const T* a, size_t l) : array(a), len(l) {}
+    public:
+        initializer_list() : array(nullptr), len(0) {}
+        size_t size() const { return len; }
+        const T *begin() const { return array; }
+        const T *end() const { return array + len; }
+    };
+
+#endif // ARX_TYPE_TRAITS_INITIALIZER_LIST_DEFINED
+
+} // namespace std
+
+#include "tuple.h"
+#include "functional.h"
+
+#endif // ARX_TYPE_TRAITS_DISABLE_STL
+
+
+#if __cplusplus < 201402L // C++11
+#if !defined(OF_VERSION_MAJOR) || !defined(TARGET_WIN32)
+
+namespace std {
+
+    template <bool B, typename T = void>
+    using enable_if_t = typename std::enable_if<B, T>::type;
+
+    template <typename T>
+    using decay_t = typename std::decay<T>::type;
+
+    template<class T>
+    using remove_cv_t = typename std::remove_cv<T>::type;
+    template<class T>
+    using remove_const_t = typename std::remove_const<T>::type;
+    template<class T>
+    using remove_volatile_t = typename std::remove_volatile<T>::type;
+    template<class T>
+    using remove_reference_t = typename std::remove_reference<T>::type;
+    template<class T>
+    using remove_pointer_t = typename std::remove_pointer<T>::type;
+
+    template<typename T, T ...Ts>
+    struct integer_sequence
+    {
+        using type = integer_sequence;
+        using value_type = T;
+        static constexpr size_t size() noexcept { return sizeof...(Ts); }
+    };
+    template <size_t ...Is>
+    using index_sequence = integer_sequence<size_t, Is...>;
+
+    // https://stackoverflow.com/questions/17424477/implementation-c14-make-integer-sequence
+
+    template<typename S1, typename S2>
+    struct concat_impl;
+    template<typename S1, typename S2>
+    using concat = typename concat_impl<S1, S2>::type;
+
+    template<size_t... I1, size_t... I2>
+    struct concat_impl <index_sequence<I1...>, index_sequence<I2...>>
+    : index_sequence<I1..., (sizeof...(I1) + I2)...> {};
+    template<size_t N>
+    struct make_index_sequence_impl;
+    template<size_t N>
+    using make_index_sequence = typename make_index_sequence_impl<N>::type;
+    template<size_t N>
+    struct make_index_sequence_impl
+    : concat<make_index_sequence <N/2>, make_index_sequence <N - N/2>> {};
+    template<>
+    struct make_index_sequence_impl <0> : index_sequence<>{};
+    template<>
+    struct make_index_sequence_impl <1> : index_sequence<0>{};
+
+    template<typename... Ts>
+    using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
+
+} // namespace std
+
+#endif // !defined(OF_VERSION_MAJOR) || !defined(TARGET_WIN32)
+#endif // C++11
+
+
+#if __cplusplus < 201703L // C++14
+
+namespace std {
+
+#if !defined(OF_VERSION_MAJOR) || !defined(TARGET_WIN32)
+
+    template <class... Ts>
+    struct Tester { using type = void; };
+    template <class... Ts>
+    using void_t = typename Tester<Ts...>::type;
+
+    template <typename ...Args>
+    struct disjunction : std::false_type {};
+    template <typename Arg>
+    struct disjunction <Arg> : Arg::type {};
+    template <typename Arg, typename ...Args>
+    struct disjunction <Arg, Args...> : std::conditional<Arg::value, Arg, disjunction<Args...>>::type {};
+
+    template <typename ...Args>
+    struct conjunction : std::true_type {};
+    template <typename Arg>
+    struct conjunction <Arg> : Arg::type {};
+    template <typename Arg, typename ...Args>
+    struct conjunction <Arg, Args...> : std::conditional<Arg::value, conjunction<Args...>, Arg>::type {};
+
+    template <typename T>
+    struct negation : std::integral_constant<bool, !T::value> {};
+
+#endif // !defined(OF_VERSION_MAJOR) || !defined(TARGET_WIN32)
+
+    // https://qiita.com/_EnumHack/items/92e6e135174f1f781dbb
+    // without decltype(auto)
+
+    template <class F, class Tuple, size_t... I>
+    constexpr auto apply_impl(F&& f, Tuple&& t, index_sequence<I...>)
+    -> decltype(f(std::get<I>(std::forward<Tuple>(t))...))
+    {
+        return f(std::get<I>(std::forward<Tuple>(t))...);
+    }
+    template <class F, class Tuple>
+    constexpr auto apply(F&& f, Tuple&& t)
+    -> decltype(apply_impl(
+        std::forward<F>(f),
+        std::forward<Tuple>(t),
+        make_index_sequence<std::tuple_size<decay_t<Tuple>>::value>{}
+    ))
+    {
+        return apply_impl(
+            std::forward<F>(f),
+            std::forward<Tuple>(t),
+            make_index_sequence<std::tuple_size<decay_t<Tuple>>::value>()
+        );
+    }
+
+} // namespace std
+
+#endif // C++14
+
+
+// C++17, C++2a
+namespace std {
+
+    template<class T>
+    struct remove_cvref
+    {
+        typedef std::remove_cv_t<std::remove_reference_t<T>> type;
+    };
+
+    template< class T >
+    using remove_cvref_t = typename remove_cvref<T>::type;
+
+} // namespace std
+// C++17, C++2a
+
+
+namespace arx { // others
+
+    template <class AlwaysVoid, template<class...> class Check, class... T>
+    struct is_detected_impl : std::false_type {};
+    template <template <class...> class Check, class... T>
+    struct is_detected_impl <std::void_t<Check<T...>>, Check, T...> : std::true_type {};
+    template <template <class...> class Check, class... T>
+    using is_detected = is_detected_impl<void, Check, T...>;
+
+
+    template <typename T>
+    struct is_callable {
+        template <typename U, decltype(&U::operator()) = &U::operator()>
+        struct checker {};
+        template <typename U> static std::true_type  test(checker<U> *);
+        template <typename>   static std::false_type test(...);
+        static constexpr bool value = decltype(test<T>(nullptr))::value;
+    };
+    template <typename R, typename ... Arguments>
+    struct is_callable<R(*)(Arguments ...)> {
+        static constexpr bool value = true;
+    };
+    template <typename R, typename ... Arguments>
+    struct is_callable<R(*&)(Arguments ...)> {
+        static constexpr bool value = true;
+    };
+    template <typename R, typename ... Arguments>
+    struct is_callable<R(&)(Arguments ...)> {
+        static constexpr bool value = true;
+    };
+    template <typename R, typename ... Arguments>
+    struct is_callable<R(Arguments ...)> {
+        static constexpr bool value = true;
+    };
+    template <typename R, typename ... Arguments>
+    struct is_callable<std::function<R(Arguments ...)>> {
+        static constexpr bool value = true;
+    };
+
+
+    namespace detail {
+        template <typename ret, typename ... arguments>
+        struct function_traits {
+            static constexpr size_t arity = sizeof...(arguments);
+            using result_type = ret;
+            using arguments_types_tuple = std::tuple<arguments ...>;
+            // template <size_t index>
+            // using argument_type = type_at<index, arguments ...>;
+            using function_type = std::function<ret(arguments ...)>;
+            template <typename function_t>
+            static constexpr function_type cast(function_t f) {
+                return static_cast<function_type>(f);
+            }
+        };
+    };
+    template <typename T>
+    struct function_traits : public function_traits<decltype(&T::operator())> {};
+    template <typename class_type, typename ret, typename ... arguments>
+    struct function_traits<ret(class_type::*)(arguments ...) const>
+    : detail::function_traits<ret, arguments ...> {};
+
+    template <typename class_type, typename ret, typename ... arguments>
+    struct function_traits<ret(class_type::*)(arguments ...)>
+    : detail::function_traits<ret, arguments ...> {};
+
+    template <typename ret, typename ... arguments>
+    struct function_traits<ret(*)(arguments ...)>
+    : detail::function_traits<ret, arguments ...> {};
+
+    template <typename ret, typename ... arguments>
+    struct function_traits<ret(*&)(arguments ...)>
+    : detail::function_traits<ret, arguments ...> {};
+
+    template <typename ret, typename ... arguments>
+    struct function_traits<ret(arguments ...)>
+    : detail::function_traits<ret, arguments ...> {};
+
+    template <typename ret, typename ... arguments>
+    struct function_traits<std::function<ret(arguments ...)>>
+    : detail::function_traits<ret, arguments ...> {};
+
+} // namespace arx
+
+#endif // ARX_TYPE_TRAITS_TYPE_TRAITS_H
diff --git a/Tween/util/ArxTypeTraits/LICENSE b/Tween/util/ArxTypeTraits/LICENSE
new file mode 100644
index 0000000..6f5269b
--- /dev/null
+++ b/Tween/util/ArxTypeTraits/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Hideaki Tai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/Tween/util/ArxTypeTraits/README.md b/Tween/util/ArxTypeTraits/README.md
new file mode 100644
index 0000000..a144f4d
--- /dev/null
+++ b/Tween/util/ArxTypeTraits/README.md
@@ -0,0 +1,109 @@
+# ArxTypeTraits
+
+C++ type_traits for Arduino which cannot use it as default
+
+
+## Supported Boards
+
+C++11 class templates of this library is currently enabled only if you use following architecture to avoid conflict with standard `type_traits`.
+
+- AVR (Uno, Nano, Mega, etc.)
+- MEGAAVR (Uno WiFi, Nano Ecery, etc.)
+- SAMD (Zero, MKR, M0, etc.)
+- SPRESENSE
+
+Others are automatically enabled/disabled depending on compiler.
+
+
+## Supported Class Templates
+
+### C++11 (defined only for platforms above which cannot use `type_traits`)
+
+- `std::integral_constant`
+- `std::true_type`
+- `std::false_type`
+- `std::declval`
+- `std::enable_if`
+- `std::conditional`
+- `std::remove_cv`
+- `std::remove_const`
+- `std::remove_volatile`
+- `std::remove_pointer`
+- `std::remove_reference`
+- `std::remove_extent`
+- `std::add_pointer`
+- `std::forward`
+- `std::is_same`
+- `std::is_integral`
+- `std::is_floating_point`
+- `std::is_arithmetic`
+- `std::is_signed`
+- `std::is_unsigned`
+- `std::is_pointer`
+- `std::is_array`
+- `std::is_convertible`
+- `std::is_function`
+- `std::is_empty`
+- `std::decay`
+- `std::result_of`
+
+
+#### for utility
+
+- `std::numeric_limits` (only `max()` and `min()` now)
+- `std::swap`
+- `std::initializer_list`
+- `std::tuple`
+- `std::get`
+- `std::tuple_size`
+- `std::function`
+
+
+### C++14 (defined only for boards before C++14)
+
+- `std::enable_if_t`
+- `std::decay_t`
+- `std::remove_cv_t`
+- `std::remove_const_t`
+- `std::remove_volatile_t`
+- `std::remove_reference_t`
+- `std::remove_pointer_t`
+- `std::integer_sequence`
+- `std::index_sequence`
+- `std::make_index_sequence`
+- `std::index_sequence_for`
+
+
+### C++17 (defined only for boards before C++17)
+
+- `std::void_t`
+- `std::disjunction`
+- `std::conjunction`
+- `std::negation`
+- `std::apply`
+
+
+### C++2a
+
+- `std::remove_cvref`
+- `std::remove_cvref_t`
+
+
+### Others (defined for all boards)
+
+- `arx::is_detected`
+- `arx::is_callable`
+- `arx::function_traits`
+
+
+## Used Inside of
+
+- [Packetizer](https://github.com/hideakitai/Packetizer)
+- [MsgPack](https://github.com/hideakitai/MsgPack)
+- [MsgPacketizer](https://github.com/hideakitai/MsgPacketizer)
+- [ArduinoOSC](https://github.com/hideakitai/ArduinoOSC)
+
+
+## License
+
+MIT
diff --git a/Tween/util/ArxTypeTraits/library.json b/Tween/util/ArxTypeTraits/library.json
new file mode 100644
index 0000000..4be6e75
--- /dev/null
+++ b/Tween/util/ArxTypeTraits/library.json
@@ -0,0 +1,20 @@
+{
+    "name": "ArxTypeTraits",
+    "keywords": "type traits, functional, tuple, stl",
+    "description": "C++ type_traits for Arduino which cannot use it as default",
+    "repository":
+    {
+        "type": "git",
+        "url": "https://github.com/hideakitai/ArxTypeTraits.git"
+    },
+    "authors":
+    {
+        "name": "Hideaki Tai",
+        "url": "https://github.com/hideakitai",
+        "maintainer": true
+    },
+    "version": "0.1.11",
+    "license": "MIT",
+    "frameworks": "arduino",
+    "platforms": "*"
+}
diff --git a/Tween/util/ArxTypeTraits/library.properties b/Tween/util/ArxTypeTraits/library.properties
new file mode 100644
index 0000000..3105b21
--- /dev/null
+++ b/Tween/util/ArxTypeTraits/library.properties
@@ -0,0 +1,9 @@
+name=ArxTypeTraits
+version=0.1.11
+author=hideakitai
+maintainer=hideakitai
+sentence=C++ type_traits for Arduino which cannot use it as default
+paragraph=C++ type_traits for Arduino which cannot use it as default
+category=Data Storage
+url=https://github.com/hideakitai
+architectures=*
diff --git a/Tween/util/Easing/Easing.h b/Tween/util/Easing/Easing.h
new file mode 100644
index 0000000..7e6b84e
--- /dev/null
+++ b/Tween/util/Easing/Easing.h
@@ -0,0 +1,30 @@
+/*
+ * Easing Functions: Copyright (c) 2010 Andy Brown
+ * http://www.andybrown.me.uk
+ *
+ * This work is licensed under a Creative Commons
+ * Attribution_ShareAlike 3.0 Unported License.
+ * http://creativecommons.org/licenses/by_sa/3.0/
+ */
+
+#pragma once
+#ifndef HT_TWEEN_EASING_LIBRARY_H
+#define HT_TWEEN_EASING_LIBRARY_H
+
+#include "Easing/BackEase.h"
+#include "Easing/BounceEase.h"
+#include "Easing/CircularEase.h"
+#include "Easing/CubicEase.h"
+#include "Easing/ElasticEase.h"
+#include "Easing/ExponentialEase.h"
+#include "Easing/LinearEase.h"
+#include "Easing/QuadraticEase.h"
+#include "Easing/QuarticEase.h"
+#include "Easing/QuinticEase.h"
+#include "Easing/SineEase.h"
+
+namespace Ease = ht::ease;
+template <typename EasingType>
+using EasingFunc = Ease::Easing<EasingType>;
+
+#endif // HT_TWEEN_EASING_LIBRARY_H
diff --git a/Tween/util/Easing/Easing/BackEase.h b/Tween/util/Easing/Easing/BackEase.h
new file mode 100644
index 0000000..a6e90f2
--- /dev/null
+++ b/Tween/util/Easing/Easing/BackEase.h
@@ -0,0 +1,75 @@
+/*
+ * Easing Functions: Copyright (c) 2010 Andy Brown
+ * http://www.andybrown.me.uk
+ *
+ * This work is licensed under a Creative Commons
+ * Attribution_ShareAlike 3.0 Unported License.
+ * http://creativecommons.org/licenses/by_sa/3.0/
+ */
+
+#pragma once
+#ifndef HT_TWEEN_EASING_BACKEASE_H
+#define HT_TWEEN_EASING_BACKEASE_H
+
+#include "EasingBase.h"
+#include "Types.h"
+
+namespace ht {
+namespace ease {
+
+class BackEase : public EasingBase
+{
+    double v_overshoot {1.70158};
+
+public:
+
+    virtual ~BackEase() {}
+
+    virtual double easeIn(double t) const
+    {
+        t /= t_scale;
+        return v_scale * t * t * ((v_overshoot + 1.) * t - v_overshoot);
+    }
+
+    virtual double easeOut(double t) const
+    {
+        t = t / t_scale - 1.;
+        return v_scale * (t * t * ((v_overshoot + 1.) * t + v_overshoot) + 1.);
+    }
+
+    virtual double easeInOut(double t) const
+    {
+        double overshoot = v_overshoot * 1.525;
+        t /= t_scale / 2.;
+        if(t < 1.)
+            return v_scale / 2. * (t * t * ((overshoot + 1.) * t - overshoot));
+        t -= 2.;
+        return v_scale / 2. * (t * t * ((overshoot + 1.) * t + overshoot) + 2.);
+    }
+
+    void overshoot(const double ovs) { v_overshoot = ovs; }
+    double overshoot() const { return v_overshoot; }
+};
+
+template <>
+struct Easing<BackIn> : public BackEase
+{
+    double get(const double t) const { return BackEase::easeIn(t); }
+};
+
+template <>
+struct Easing<BackOut> : public BackEase
+{
+    double get(const double t) const { return BackEase::easeOut(t); }
+};
+
+template <>
+struct Easing<BackInOut> : public BackEase
+{
+    double get(const double t) const { return BackEase::easeInOut(t); }
+};
+
+} // ease
+} // ht
+
+#endif // HT_TWEEN_EASING_BACKEASE_H
diff --git a/Tween/util/Easing/Easing/BounceEase.h b/Tween/util/Easing/Easing/BounceEase.h
new file mode 100644
index 0000000..f93b02c
--- /dev/null
+++ b/Tween/util/Easing/Easing/BounceEase.h
@@ -0,0 +1,79 @@
+/*
+ * Easing Functions: Copyright (c) 2010 Andy Brown
+ * http://www.andybrown.me.uk
+ *
+ * This work is licensed under a Creative Commons
+ * Attribution_ShareAlike 3.0 Unported License.
+ * http://creativecommons.org/licenses/by_sa/3.0/
+ */
+
+#pragma once
+#ifndef HT_TWEEN_EASING_BOUNCEEASE_H
+#define HT_TWEEN_EASING_BOUNCEEASE_H
+
+#include "EasingBase.h"
+
+namespace ht {
+namespace ease {
+
+class BounceEase : public EasingBase
+{
+public:
+
+    virtual ~BounceEase() {}
+
+    virtual double easeIn(double t) const
+    {
+        return v_scale - easeOut(t_scale - t);
+    }
+
+    virtual double easeOut(double t) const
+    {
+        t /= t_scale;
+        if (t < (1. / 2.75))
+            return v_scale * (7.5625 * t * t);
+        else if (t < (2. / 2.75))
+        {
+            t -= 1.5 / 2.75;
+            return v_scale * (7.5625 * t * t + 0.75);
+        }
+        else if (t < (2.5 / 2.75))
+        {
+            t -= 2.25 / 2.75;
+            return v_scale * (7.5625 * t * t + 0.9375);
+        }
+        t -= 2.625 / 2.75;
+        return v_scale * (7.5625 * t * t + 0.984375);
+    }
+
+    virtual double easeInOut(double t) const
+    {
+        if(t < t_scale / 2.)
+            return easeIn(t * 2.) * 0.5;
+        else
+            return easeOut(t * 2. - t_scale) * 0.5 + v_scale * 0.5;
+    }
+};
+
+template <>
+struct Easing<BounceIn> : public BounceEase
+{
+    double get(const double t) const { return BounceEase::easeIn(t); }
+};
+
+template <>
+struct Easing<BounceOut> : public BounceEase
+{
+    double get(const double t) const { return BounceEase::easeOut(t); }
+};
+
+template <>
+struct Easing<BounceInOut> : public BounceEase
+{
+    double get(const double t) const { return BounceEase::easeInOut(t); }
+};
+
+} // ease
+} // ht
+
+#endif
diff --git a/Tween/util/Easing/Easing/CircularEase.h b/Tween/util/Easing/Easing/CircularEase.h
new file mode 100644
index 0000000..fb4447f
--- /dev/null
+++ b/Tween/util/Easing/Easing/CircularEase.h
@@ -0,0 +1,67 @@
+/*
+ * Easing Functions: Copyright (c) 2010 Andy Brown
+ * http://www.andybrown.me.uk
+ *
+ * This work is licensed under a Creative Commons
+ * Attribution_ShareAlike 3.0 Unported License.
+ * http://creativecommons.org/licenses/by_sa/3.0/
+ */
+
+#pragma once
+#ifndef HT_TWEEN_EASING_CIRCULAREASE_H
+#define HT_TWEEN_EASING_CIRCULAREASE_H
+
+#include "EasingBase.h"
+
+namespace ht {
+namespace ease {
+
+class CircularEase : public EasingBase
+{
+public:
+
+    virtual ~CircularEase() {}
+
+    virtual double easeIn(double t) const
+    {
+        t /= t_scale;
+        return -v_scale * (sqrt(1. - t * t) - 1.);
+    }
+
+    virtual double easeOut(double t) const
+    {
+        t = t / t_scale - 1.;
+        return v_scale * sqrt(1. - t * t);
+    }
+
+    virtual double easeInOut(double t) const
+    {
+        t /= t_scale / 2.;
+        if(t < 1.) return -v_scale / 2. * (sqrt(1. - t * t) - 1.);
+        t -= 2.;
+        return v_scale / 2. * (sqrt(1. - t * t) + 1.);
+    }
+};
+
+template <>
+struct Easing<CircIn> : public CircularEase
+{
+    double get(const double t) const { return CircularEase::easeIn(t); }
+};
+
+template <>
+struct Easing<CircOut> : public CircularEase
+{
+    double get(const double t) const { return CircularEase::easeOut(t); }
+};
+
+template <>
+struct Easing<CircInOut> : public CircularEase
+{
+    double get(const double t) const { return CircularEase::easeInOut(t); }
+};
+
+} // ease
+} // ht
+
+#endif
diff --git a/Tween/util/Easing/Easing/CubicEase.h b/Tween/util/Easing/Easing/CubicEase.h
new file mode 100644
index 0000000..b85b92b
--- /dev/null
+++ b/Tween/util/Easing/Easing/CubicEase.h
@@ -0,0 +1,67 @@
+/*
+ * Easing Functions: Copyright (c) 2010 Andy Brown
+ * http://www.andybrown.me.uk
+ *
+ * This work is licensed under a Creative Commons
+ * Attribution-ShareAlike 3.0 Unported License.
+ * http://creativecommons.org/licenses/by-sa/3.0/
+ */
+
+#pragma once
+#ifndef HT_TWEEN_EASING_CUBICEASE_H
+#define HT_TWEEN_EASING_CUBICEASE_H
+
+#include "EasingBase.h"
+
+namespace ht {
+namespace ease {
+
+class CubicEase : public EasingBase
+{
+public:
+
+    virtual ~CubicEase() {}
+
+    virtual double easeIn(double t) const
+    {
+        t /= t_scale;
+        return v_scale * t * t * t;
+    }
+
+    virtual double easeOut(double t) const
+    {
+        t = t / t_scale - 1.;
+        return v_scale * (t * t * t + 1.);
+    }
+
+    virtual double easeInOut(double t) const
+    {
+        t /= t_scale / 2.;
+        if (t < 1.) return v_scale / 2. * t * t * t;
+        t -= 2.;
+        return v_scale / 2. * (t * t * t + 2.);
+    }
+};
+
+template <>
+struct Easing<CubicIn> : public CubicEase
+{
+    double get(const double t) const { return CubicEase::easeIn(t); }
+};
+
+template <>
+struct Easing<CubicOut> : public CubicEase
+{
+    double get(const double t) const { return CubicEase::easeOut(t); }
+};
+
+template <>
+struct Easing<CubicInOut> : public CubicEase
+{
+    double get(const double t) const { return CubicEase::easeInOut(t); }
+};
+
+} // ease
+} // ht
+
+#endif
diff --git a/Tween/util/Easing/Easing/EasingBase.h b/Tween/util/Easing/Easing/EasingBase.h
new file mode 100644
index 0000000..d008601
--- /dev/null
+++ b/Tween/util/Easing/Easing/EasingBase.h
@@ -0,0 +1,47 @@
+/*
+ * Easing Functions: Copyright (c) 2010 Andy Brown
+ * http://www.andybrown.me.uk
+ *
+ * This work is licensed under a Creative Commons
+ * Attribution_ShareAlike 3.0 Unported License.
+ * http://creativecommons.org/licenses/by_sa/3.0/
+ */
+
+#pragma once
+#ifndef HT_TWEEN_EASING_EASINGBASE_H
+#define HT_TWEEN_EASING_EASINGBASE_H
+
+namespace ht {
+namespace ease {
+
+class EasingBase
+{
+protected:
+
+    double v_scale {1.};
+    double t_scale {1.};
+
+public:
+
+    // easing API methods
+    virtual double easeIn(double t) const = 0;
+    virtual double easeOut(double t) const = 0;
+    virtual double easeInOut(double t) const = 0;
+
+    // common properties
+    void duration(const double t) { t_scale = t; }
+    void scale(const double s) { v_scale = s; }
+    double duration() const { return t_scale; }
+    double scale() const { return v_scale; }
+};
+
+template <typename>
+struct Easing
+{
+    double get(const double t);
+};
+
+} // ease
+} // ht
+
+#endif
diff --git a/Tween/util/Easing/Easing/ElasticEase.h b/Tween/util/Easing/Easing/ElasticEase.h
new file mode 100644
index 0000000..2cd4c72
--- /dev/null
+++ b/Tween/util/Easing/Easing/ElasticEase.h
@@ -0,0 +1,132 @@
+/*
+ * Easing Functions: Copyright (c) 2010 Andy Brown
+ * http://www.andybrown.me.uk
+ *
+ * This work is licensed under a Creative Commons
+ * Attribution-ShareAlike 3.0 Unported License.
+ * http://creativecommons.org/licenses/by-sa/3.0/
+ */
+
+#pragma once
+#ifndef HT_TWEEN_EASING_ELASTICEASE_H
+#define HT_TWEEN_EASING_ELASTICEASE_H
+
+#include "EasingBase.h"
+
+namespace ht {
+namespace ease {
+
+class ElasticEase : public EasingBase
+{
+    double v_period {0};
+    double v_amplitude {0};
+
+public:
+
+    virtual ~ElasticEase() {}
+
+    virtual double easeIn(double t) const
+    {
+        if (t == 0) return 0;
+        t /= t_scale;
+        if (t == 1) return v_scale;
+
+        double p, a, s;
+
+        if (v_period == 0.) p = t_scale * 0.3;
+        else               p = v_period;
+
+        a = v_amplitude;
+        if (a == 0. || a < fabs(v_scale))
+        {
+            a = v_scale;
+            s = p / 4.;
+        }
+        else
+            s = p / (2. * M_PI) * asin(v_scale / a);
+
+        t -= 1.;
+        return -(a * pow(2., 10. * t) * sin((t * t_scale - s) * (2. * M_PI) / p));
+    }
+
+    virtual double easeOut(double t) const
+    {
+        if (t == 0.) return 0;
+        t /= t_scale;
+        if (t == 1.) return v_scale;
+
+        double p, a, s;
+
+        if (v_period == 0.) p = t_scale * 0.3;
+        else               p = v_period;
+
+        a = v_amplitude;
+        if (a == 0 || a < fabs(v_scale))
+        {
+            a = v_scale;
+            s = p / 4.;
+        }
+        else
+            s = p / (2. * M_PI) * asin(v_scale / a);
+
+        return a * pow(2., -10. * t) * sin((t * t_scale - s) * (2. * M_PI) / p) + v_scale;
+    }
+
+    virtual double easeInOut(double t) const
+    {
+        if (t == 0.) return 0;
+        t /= t_scale / 2.;
+        if (t == 2.) return v_scale;
+
+        double p, a, s;
+
+        if (v_period == 0.) p = t_scale * (0.3 * 1.5);
+        else               p = v_period;
+
+        a = v_amplitude;
+        if (a == 0 || a < fabs(v_scale))
+        {
+            a = v_scale;
+            s = p / 4.;
+        }
+        else
+            s = p / (2. * M_PI) * asin(v_scale / a);
+
+        if (t < 1.)
+        {
+            t -= 1.;
+            return -0.5 * (a * pow(2., 10. * t) * sin((t * t_scale - s) * (2. * M_PI) / p));
+        }
+
+        t -= 1.;
+        return a * pow(2., -10. * t) * sin((t * t_scale - s) * (2. * M_PI) / p) * 0.5 + v_scale;
+    }
+
+    void period(const double p) { v_period = p; }
+    void amplitude(const double a) { v_amplitude = a; }
+    double period() const { return v_period; }
+    double amplitude() const { return v_amplitude; }
+};
+
+template <>
+struct Easing<ElasticIn> : public ElasticEase
+{
+    double get(const double t) const { return ElasticEase::easeIn(t); }
+};
+
+template <>
+struct Easing<ElasticOut> : public ElasticEase
+{
+    double get(const double t) const { return ElasticEase::easeOut(t); }
+};
+
+template <>
+struct Easing<ElasticInOut> : public ElasticEase
+{
+    double get(const double t) const { return ElasticEase::easeInOut(t); }
+};
+
+} // ease
+} // ht
+
+#endif
diff --git a/Tween/util/Easing/Easing/ExponentialEase.h b/Tween/util/Easing/Easing/ExponentialEase.h
new file mode 100644
index 0000000..dacc64a
--- /dev/null
+++ b/Tween/util/Easing/Easing/ExponentialEase.h
@@ -0,0 +1,67 @@
+/*
+ * Easing Functions: Copyright (c) 2010 Andy Brown
+ * http://www.andybrown.me.uk
+ *
+ * This work is licensed under a Creative Commons
+ * Attribution-ShareAlike 3.0 Unported License.
+ * http://creativecommons.org/licenses/by-sa/3.0/
+ */
+
+#pragma once
+#ifndef HT_TWEEN_EASING_EXPONENTIALEASE_H
+#define HT_TWEEN_EASING_EXPONENTIALEASE_H
+
+#include "EasingBase.h"
+
+namespace ht {
+namespace ease {
+
+class ExponentialEase : public EasingBase
+{
+public:
+
+    virtual ~ExponentialEase() {}
+
+    virtual double easeIn(double t) const
+    {
+        return (t == 0.) ? 0. : v_scale * pow(2., 10. * (t / t_scale - 1.));
+    }
+
+    virtual double easeOut(double t) const
+    {
+        return (t == t_scale) ? v_scale : v_scale * (-pow(2., -10. * t / t_scale) + 1.);
+    }
+
+    virtual double easeInOut(double t) const
+    {
+        if(t == 0.)       return 0;
+        if(t == t_scale) return v_scale;
+        t /= t_scale / 2.;
+        if(t < 1.) return v_scale / 2. * pow(2., 10. * (t - 1.));
+        t -= 1.;
+        return v_scale / 2. * (-pow(2., -10. * t) + 2.);
+    }
+};
+
+template <>
+struct Easing<ExpoIn> : public ExponentialEase
+{
+    double get(const double t) const { return ExponentialEase::easeIn(t); }
+};
+
+template <>
+struct Easing<ExpoOut> : public ExponentialEase
+{
+    double get(const double t) const { return ExponentialEase::easeOut(t); }
+};
+
+template <>
+struct Easing<ExpoInOut> : public ExponentialEase
+{
+    double get(const double t) const { return ExponentialEase::easeInOut(t); }
+};
+
+} // ease
+} // ht
+
+#endif
diff --git a/Tween/util/Easing/Easing/LICENSE.txt b/Tween/util/Easing/Easing/LICENSE.txt
new file mode 100644
index 0000000..f14190a
--- /dev/null
+++ b/Tween/util/Easing/Easing/LICENSE.txt
@@ -0,0 +1,8 @@
+/*
+ * Easing Functions: Copyright (c) 2010 Andy Brown
+ * http://www.andybrown.me.uk
+ *
+ * This work is licensed under a Creative Commons
+ * Attribution_ShareAlike 3.0 Unported License.
+ * http://creativecommons.org/licenses/by_sa/3.0/
+ */
diff --git a/Tween/util/Easing/Easing/LinearEase.h b/Tween/util/Easing/Easing/LinearEase.h
new file mode 100644
index 0000000..97168b5
--- /dev/null
+++ b/Tween/util/Easing/Easing/LinearEase.h
@@ -0,0 +1,62 @@
+/*
+ * Easing Functions: Copyright (c) 2010 Andy Brown
+ * http://www.andybrown.me.uk
+ *
+ * This work is licensed under a Creative Commons
+ * Attribution-ShareAlike 3.0 Unported License.
+ * http://creativecommons.org/licenses/by-sa/3.0/
+ */
+
+#pragma once
+#ifndef HT_TWEEN_EASING_LINEAREASE_H
+#define HT_TWEEN_EASING_LINEAREASE_H
+
+#include "EasingBase.h"
+
+namespace ht {
+namespace ease {
+
+class LinearEase : public EasingBase
+{
+public:
+
+    virtual ~LinearEase() {}
+
+    virtual double easeIn(double t) const
+    {
+        return v_scale * t / t_scale;
+    }
+
+    virtual double easeOut(double t) const
+    {
+        return easeIn(t);
+    }
+
+    virtual double easeInOut(double t) const
+    {
+        return easeIn(t);
+    }
+};
+
+template <>
+struct Easing<LinearIn> : public LinearEase
+{
+    double get(const double t) const { return LinearEase::easeIn(t); }
+};
+
+template <>
+struct Easing<LinearOut> : public LinearEase
+{
+    double get(const double t) const { return LinearEase::easeOut(t); }
+};
+
+template <>
+struct Easing<LinearInOut> : public LinearEase
+{
+    double get(const double t) const { return LinearEase::easeInOut(t); }
+};
+
+} // ease
+} // ht
+
+#endif
diff --git a/Tween/util/Easing/Easing/QuadraticEase.h b/Tween/util/Easing/Easing/QuadraticEase.h
new file mode 100644
index 0000000..d86853e
--- /dev/null
+++ b/Tween/util/Easing/Easing/QuadraticEase.h
@@ -0,0 +1,67 @@
+/*
+ * Easing Functions: Copyright (c) 2010 Andy Brown
+ * http://www.andybrown.me.uk
+ *
+ * This work is licensed under a Creative Commons
+ * Attribution-ShareAlike 3.0 Unported License.
+ * http://creativecommons.org/licenses/by-sa/3.0/
+ */
+
+#pragma once
+#ifndef HT_TWEEN_EASING_QUADRATICEASE_H
+#define HT_TWEEN_EASING_QUADRATICEASE_H
+
+#include "EasingBase.h"
+
+namespace ht {
+namespace ease {
+
+class QuadraticEase : public EasingBase
+{
+public:
+
+    virtual ~QuadraticEase() {}
+
+    virtual double easeIn(double t) const
+    {
+        t /= t_scale;
+        return v_scale * t * t;
+    }
+
+    virtual double easeOut(double t) const
+    {
+        t /= t_scale;
+        return -v_scale * t * (t - 2.);
+    }
+
+    virtual double easeInOut(double t) const
+    {
+        t /= t_scale / 2.;
+        if (t < 1.) return v_scale / 2. * t * t;
+        t -= 1.;
+        return -v_scale / 2. * (t * (t - 2.) - 1.);
+    }
+};
+
+template <>
+struct Easing<QuadIn> : public QuadraticEase
+{
+    double get(const double t) const { return QuadraticEase::easeIn(t); }
+};
+
+template <>
+struct Easing<QuadOut> : public QuadraticEase
+{
+    double get(const double t) const { return QuadraticEase::easeOut(t); }
+};
+
+template <>
+struct Easing<QuadInOut> : public QuadraticEase
+{
+    double get(const double t) const { return QuadraticEase::easeInOut(t); }
+};
+
+} // ease
+} // ht
+
+#endif
diff --git a/Tween/util/Easing/Easing/QuarticEase.h b/Tween/util/Easing/Easing/QuarticEase.h
new file mode 100644
index 0000000..7315c3d
--- /dev/null
+++ b/Tween/util/Easing/Easing/QuarticEase.h
@@ -0,0 +1,67 @@
+/*
+ * Easing Functions: Copyright (c) 2010 Andy Brown
+ * http://www.andybrown.me.uk
+ *
+ * This work is licensed under a Creative Commons
+ * Attribution_ShareAlike 3.0 Unported License.
+ * http://creativecommons.org/licenses/by_sa/3.0/
+ */
+
+#pragma once
+#ifndef HT_TWEEN_EASING_QUARTICEASE_H
+#define HT_TWEEN_EASING_QUARTICEASE_H
+
+#include "EasingBase.h"
+
+namespace ht {
+namespace ease {
+
+class QuarticEase : public EasingBase
+{
+public:
+
+    virtual ~QuarticEase() {}
+
+    virtual double easeIn(double t) const
+    {
+        t /= t_scale;
+        return v_scale * t * t * t * t;
+    }
+
+    virtual double easeOut(double t) const
+    {
+        t = t / t_scale - 1.;
+        return -v_scale * (t * t * t * t - 1.);
+    }
+
+    virtual double easeInOut(double t) const
+    {
+        t /= t_scale / 2.;
+        if(t < 1.) return v_scale / 2. * t * t * t * t;
+        t -= 2.;
+        return -v_scale / 2. * (t * t * t * t - 2.);
+    }
+};
+
+template <>
+struct Easing<QuartIn> : public QuarticEase
+{
+    double get(const double t) const { return QuarticEase::easeIn(t); }
+};
+
+template <>
+struct Easing<QuartOut> : public QuarticEase
+{
+    double get(const double t) const { return QuarticEase::easeOut(t); }
+};
+
+template <>
+struct Easing<QuartInOut> : public QuarticEase
+{
+    double get(const double t) const { return QuarticEase::easeInOut(t); }
+};
+
+} // ease
+} // ht
+
+#endif
diff --git a/Tween/util/Easing/Easing/QuinticEase.h b/Tween/util/Easing/Easing/QuinticEase.h
new file mode 100644
index 0000000..82fdd64
--- /dev/null
+++ b/Tween/util/Easing/Easing/QuinticEase.h
@@ -0,0 +1,67 @@
+/*
+ * Easing Functions: Copyright (c) 2010 Andy Brown
+ * http://www.andybrown.me.uk
+ *
+ * This work is licensed under a Creative Commons
+ * Attribution_ShareAlike 3.0 Unported License.
+ * http://creativecommons.org/licenses/by_sa/3.0/
+ */
+
+#pragma once
+#ifndef HT_TWEEN_EASING_QUINTICEASE_H
+#define HT_TWEEN_EASING_QUINTICEASE_H
+
+#include "EasingBase.h"
+
+namespace ht {
+namespace ease {
+
+class QuinticEase : public EasingBase
+{
+public:
+
+    virtual ~QuinticEase() {}
+
+    virtual double easeIn(double t) const
+    {
+        t /= t_scale;
+        return v_scale * t * t * t * t * t;
+    }
+
+    virtual double easeOut(double t) const
+    {
+        t = t / t_scale - 1.;
+        return v_scale * (t * t * t * t * t + 1.);
+    }
+
+    virtual double easeInOut(double t) const
+    {
+        t /= t_scale / 2.;
+        if (t < 1.) return v_scale / 2. * t * t * t * t * t;
+        t -= 2.;
+        return v_scale / 2. * (t * t * t * t * t + 2.);
+    }
+};
+
+template <>
+struct Easing<QuintIn> : public QuinticEase
+{
+    double get(const double t) const { return QuinticEase::easeIn(t); }
+};
+
+template <>
+struct Easing<QuintOut> : public QuinticEase
+{
+    double get(const double t) const { return QuinticEase::easeOut(t); }
+};
+
+template <>
+struct Easing<QuintInOut> : public QuinticEase
+{
+    double get(const double t) const { return QuinticEase::easeInOut(t); }
+};
+
+} // ease
+} // ht
+
+#endif
diff --git a/Tween/util/Easing/Easing/SineEase.h b/Tween/util/Easing/Easing/SineEase.h
new file mode 100644
index 0000000..84af8c6
--- /dev/null
+++ b/Tween/util/Easing/Easing/SineEase.h
@@ -0,0 +1,62 @@
+/*
+ * Easing Functions: Copyright (c) 2010 Andy Brown
+ * http://www.andybrown.me.uk
+ *
+ * This work is licensed under a Creative Commons
+ * Attribution_ShareAlike 3.0 Unported License.
+ * http://creativecommons.org/licenses/by_sa/3.0/
+ */
+
+#pragma once
+#ifndef HT_TWEEN_EASING_SINEEASE_H
+#define HT_TWEEN_EASING_SINEEASE_H
+
+#include "EasingBase.h"
+
+namespace ht {
+namespace ease {
+
+class SineEase : public EasingBase
+{
+public:
+
+    virtual ~SineEase() {}
+
+    virtual double easeIn(double t) const
+    {
+        return -v_scale * cos(t / t_scale * M_PI_2) + v_scale;
+    }
+
+    virtual double easeOut(double t) const
+    {
+        return v_scale * sin(t / t_scale * M_PI_2);
+    }
+
+    virtual double easeInOut(double t) const
+    {
+        return -v_scale / 2. * (cos(M_PI * t / t_scale) - 1.);
+    }
+};
+
+template <>
+struct Easing<SineIn> : public SineEase
+{
+    double get(const double t) const { return SineEase::easeIn(t); }
+};
+
+template <>
+struct Easing<SineOut> : public SineEase
+{
+    double get(const double t) const { return SineEase::easeOut(t); }
+};
+
+template <>
+struct Easing<SineInOut> : public SineEase
+{
+    double get(const double t) const { return SineEase::easeInOut(t); }
+};
+
+} // ease
+} // ht
+
+#endif
diff --git a/Tween/util/Easing/Easing/Types.h b/Tween/util/Easing/Easing/Types.h
new file mode 100644
index 0000000..c4926f5
--- /dev/null
+++ b/Tween/util/Easing/Easing/Types.h
@@ -0,0 +1,68 @@
+#pragma once
+#ifndef HT_TWEEN_EASING_TYPES_H
+#define HT_TWEEN_EASING_TYPES_H
+
+#include "EasingBase.h"
+
+namespace ht {
+namespace ease {
+
+    struct BackIn {};
+    struct BackOut {};
+    struct BackInOut {};
+    using Back = BackInOut;
+
+    struct BounceIn {};
+    struct BounceOut {};
+    struct BounceInOut {};
+    using Bounce = BounceInOut;
+
+    struct CircIn {};
+    struct CircOut {};
+    struct CircInOut {};
+    using Circ = CircInOut;
+
+    struct CubicIn {};
+    struct CubicOut {};
+    struct CubicInOut {};
+    using Cubic = CubicInOut;
+
+    struct ElasticIn {};
+    struct ElasticOut {};
+    struct ElasticInOut {};
+    using Elastic = ElasticInOut;
+
+    struct ExpoIn {};
+    struct ExpoOut {};
+    struct ExpoInOut {};
+    using Expo = ExpoInOut;
+
+    struct LinearIn {};
+    struct LinearOut {};
+    struct LinearInOut {};
+    using Linear = LinearInOut;
+
+    struct QuadIn {};
+    struct QuadOut {};
+    struct QuadInOut {};
+    using Quad = QuadInOut;
+
+    struct QuartIn {};
+    struct QuartOut {};
+    struct QuartInOut {};
+    using Quart = QuartInOut;
+
+    struct QuintIn {};
+    struct QuintOut {};
+    struct QuintInOut {};
+    using Quint = QuintInOut;
+
+    struct SineIn {};
+    struct SineOut {};
+    struct SineInOut {};
+    using Sine = SineInOut;
+
+} // ease
+} // ht
+
+#endif // HT_TWEEN_EASING_TYPES_H
diff --git a/Tween/util/Easing/LICENSE b/Tween/util/Easing/LICENSE
new file mode 100644
index 0000000..6f5269b
--- /dev/null
+++ b/Tween/util/Easing/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Hideaki Tai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/Tween/util/Easing/README.md b/Tween/util/Easing/README.md
new file mode 100644
index 0000000..af943ab
--- /dev/null
+++ b/Tween/util/Easing/README.md
@@ -0,0 +1,100 @@
+# Easing
+
+Easing function library for Arduino.
+
+This library is based on the [Andy Brown's Easing Function Library](https://andybrown.me.uk/2010/12/05/animation-on-the-arduino-with-easing-functions/).
+For animating example of easing functions, see website like [this](https://easings.net/en).
+
+[Tween](https://github.com/hideakitai/Tween) library is more flexible and useful tweening library based on this easing library. Please check it for more practical use.
+
+## Usage
+
+```C++
+EasingFunc<Ease::Sine> e;
+float start;
+
+void setup()
+{
+    e.duration(duration); // default duration is 1.0
+    e.scale(scale); // default scale is 1.0
+
+    start = millis() / 1000.;
+}
+
+void loop()
+{
+    // value moves from 0.0 to scale in duration [sec]
+    float now = millis() / 1000.;
+    float value = e.get(now - start);
+
+    Serial.println(value);
+}
+```
+
+## APIs
+
+```C++
+// get automatically in/out/inout value based on easing types
+double get(const double t);
+
+void duration(const double t);
+void scale(const double s);
+double duration() const;
+double scale() const;
+
+// you can also get in/out/inout values regardless of easing type
+// (not recommended)
+double easeIn(double t) const;
+double easeOut(double t) const;
+double easeInOut(double t) const;
+```
+
+#### `Ease::Back` family only
+
+```C++
+void overshoot(const double ovs) { v_overshoot = ovs; }
+double overshoot() const { return v_overshoot; }
+```
+
+#### `Ease::Elastic` family only
+
+```C++
+void period(const double p) { v_period = p; }
+void amplitude(const double a) { v_amplitude = a; }
+double period() const { return v_period; }
+double amplitude() const { return v_amplitude; }
+```
+
+## Easing Types
+
+- BackIn, BackOut, BackInOut
+- BounceIn, BounceOut, BounceInOut
+- CircIn, CircOut, CircInOut
+- CubicIn, CubicOut, CubicInOut
+- ElasticIn, ElasticOut, ElasticInOut
+- ExpoIn, ExpoOut, ExpoInOut
+- LinearIn, LinearOut, LinearInOut
+- QuadIn, QuadOut, QuadInOut
+- QuartIn, QuartOut, QuartInOut
+- QuintIn, QuintOut, QuintInOut
+- SineIn, SineOut, SineInOut
+
+```C++
+// alias
+using Back = BackInOut;
+using Bounce = BounceInOut;
+using Circ = CircInOut;
+using Cubic = CubicInOut;
+using Elastic = ElasticInOut;
+using Expo = ExpoInOut;
+using Linear = LinearInOut;
+using Quad = QuadInOut;
+using Quart = QuartInOut;
+using Quint = QuintInOut;
+using Sine = SineInOut;
+```
+
+
+## License
+
+MIT
diff --git a/Tween/util/Easing/library.json b/Tween/util/Easing/library.json
new file mode 100644
index 0000000..23921c1
--- /dev/null
+++ b/Tween/util/Easing/library.json
@@ -0,0 +1,20 @@
+{
+    "name": "Easing",
+    "keywords": "easing, tween",
+    "description": "Easing function library for Arduino",
+    "repository":
+    {
+        "type": "git",
+        "url": "https://github.com/hideakitai/Easing.git"
+    },
+    "authors":
+    {
+        "name": "Hideaki Tai",
+        "url": "https://github.com/hideakitai",
+        "maintainer": true
+    },
+    "version": "0.1.0",
+    "license": "MIT",
+    "frameworks": "arduino",
+    "platforms": "*"
+}
diff --git a/Tween/util/Easing/library.properties b/Tween/util/Easing/library.properties
new file mode 100644
index 0000000..87483dc
--- /dev/null
+++ b/Tween/util/Easing/library.properties
@@ -0,0 +1,9 @@
+name=Easing
+version=0.1.0
+author=hideakitai
+maintainer=hideakitai
+sentence=Easing function library for Arduino
+paragraph=Easing function library for Arduino
+category=Data Processing
+url=https://github.com/hideakitai
+architectures=*
diff --git a/Tween/util/PollingTimer/FrameRateCounter.h b/Tween/util/PollingTimer/FrameRateCounter.h
new file mode 100644
index 0000000..d74e4b0
--- /dev/null
+++ b/Tween/util/PollingTimer/FrameRateCounter.h
@@ -0,0 +1,40 @@
+#pragma once
+#ifndef HT_FRAMERATECOUNTER_H
+#define HT_FRAMERATECOUNTER_H
+
+#include "IntervalCounter.h"
+
+class FrameRateCounter : public IntervalCounter
+{
+    double fps {40.};
+    bool is_one_start {false};
+
+public:
+
+    explicit FrameRateCounter(const double fps)
+    : IntervalCounter(1.0 / fps)
+    , fps(fps)
+    , is_one_start(false)
+    {}
+
+    virtual ~FrameRateCounter() {}
+
+    inline double frame()
+    {
+        return is_one_start ? (count() + 1.) : count();
+    }
+
+    inline void setFrameRate(const double rate)
+    {
+        fps = rate;
+        setInterval(1. / fps);
+    }
+
+    inline void setFirstFrameToOne(const bool b) { is_one_start = b; }
+
+    double getFrameRate() const { return fps; }
+    bool isFristFrameOne() const { return is_one_start; }
+
+};
+
+#endif // HT_FRAMERATECOUNTER_H
diff --git a/Tween/util/PollingTimer/IntervalCounter.h b/Tween/util/PollingTimer/IntervalCounter.h
new file mode 100644
index 0000000..5434727
--- /dev/null
+++ b/Tween/util/PollingTimer/IntervalCounter.h
@@ -0,0 +1,81 @@
+#pragma once
+#ifndef HT_INTERVALCOUNTER_H
+#define HT_INTERVALCOUNTER_H
+
+#include "PollingTimer.h"
+
+class IntervalCounter : public PollingTimer
+{
+    double interval {0.};
+    double cnt {0.};
+
+protected:
+
+    std::function<void(void)> func;
+
+public:
+
+    explicit IntervalCounter (const double sec)
+    : interval(sec * 1000000.)
+    , cnt(0.)
+    {}
+
+    virtual ~IntervalCounter() {}
+
+    inline void startForCount(const double duration_count = 0.)
+    {
+        PollingTimer::startForUsec((int64_t)(duration_count * interval));
+        cnt = 0;
+    }
+
+    inline void stop()
+    {
+        PollingTimer::stop();
+        cnt = 0;
+    }
+
+    inline void restart()
+    {
+        IntervalCounter::stop();
+        start();
+    }
+
+    inline double count()
+    {
+        if (isPausing()) update();
+        return (double)cnt;
+    }
+
+    inline void setInterval(const double interval_sec)
+    {
+        interval = interval_sec * 1000000.;
+    }
+
+    inline void setOffsetCount(const double offset)
+    {
+        setOffsetUsec(interval * offset);
+    }
+
+    inline void addEvent(const std::function<void(void)>& f)
+    {
+        func = f;
+    }
+
+    inline bool hasEvent() const
+    {
+        return (bool)func;
+    }
+
+    inline bool update()
+    {
+        if (isStopping()) return false;
+        double prev_cnt = cnt;
+        cnt = (double)usec() / interval;
+        bool b = (floor(cnt) > 0.) && (floor(cnt) > floor(prev_cnt));
+        if (b && func) func();
+        return b;
+    }
+
+};
+
+#endif // HT_INTERVALCOUNTER_H
diff --git a/Tween/util/PollingTimer/LICENSE b/Tween/util/PollingTimer/LICENSE
new file mode 100644
index 0000000..8c86460
--- /dev/null
+++ b/Tween/util/PollingTimer/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Hideaki Tai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/Tween/util/PollingTimer/OneShotTimer.h b/Tween/util/PollingTimer/OneShotTimer.h
new file mode 100644
index 0000000..633fcd2
--- /dev/null
+++ b/Tween/util/PollingTimer/OneShotTimer.h
@@ -0,0 +1,30 @@
+#pragma once
+#ifndef HT_ONESHOTTIMER_H
+#define HT_ONESHOTTIMER_H
+
+#include "IntervalCounter.h"
+
+class OneShotTimer : public IntervalCounter
+{
+public:
+
+    virtual ~OneShotTimer() {}
+
+    explicit OneShotTimer(const double sec)
+    : IntervalCounter(sec)
+    {}
+
+    OneShotTimer(const double sec, const std::function<void(void)>& f)
+    : IntervalCounter(sec)
+    {
+        IntervalCounter::addEvent(f);
+    }
+
+    void start()
+    {
+        IntervalCounter::startForCount(1);
+    }
+
+};
+
+#endif // HT_ONESHOTTIMER_H
diff --git a/Tween/util/PollingTimer/PollingTimer.h b/Tween/util/PollingTimer/PollingTimer.h
new file mode 100644
index 0000000..64c27eb
--- /dev/null
+++ b/Tween/util/PollingTimer/PollingTimer.h
@@ -0,0 +1,254 @@
+#pragma once
+#ifndef HT_POLLINGTIMER_H
+#define HT_POLLINGTIMER_H
+
+#ifdef ARDUINO
+    #include <Arduino.h>
+    #include "util/ArxTypeTraits/ArxTypeTraits.h"
+    #include "util/TeensyDirtySTLErrorSolution/TeensyDirtySTLErrorSolution.h"
+    #define MICROS() micros()
+#elif defined(OF_VERSION_MAJOR)
+    #include "ofMain.h"
+    #include <functional>
+    #define MICROS() ofGetElapsedTimeMicros()
+#else
+    #error THIS PLATFORM IS NOT SUPPORTED
+#endif
+
+class PollingTimer
+{
+protected:
+
+    static constexpr int64_t  UINT32_NUMERIC_LIMIT_MAX  {0x00000000FFFFFFFF};
+    static constexpr uint32_t UINT32_NUMERIC_LIMIT_HALF {0x7FFFFFFF};
+
+    bool running {false};
+    bool prev_running {false};
+
+    uint32_t prev_us32 {0};
+    int64_t prev_us64 {0};
+    int64_t origin {0};
+    uint32_t ovf {0};
+    int64_t offset {0};
+    int64_t duration {0};
+
+public:
+
+    virtual ~PollingTimer() {}
+
+    inline void start()
+    {
+        startFromForUsec64(0, 0);
+    }
+    inline void startFrom(const double from_sec)
+    {
+        startFromForUsec64(from_sec * 1000000., 0);
+    }
+    inline void startFromMsec(const double from_ms)
+    {
+        startFromForUsec64(from_ms * 1000., 0);
+    }
+    inline void startFromUsec(const double from_us)
+    {
+        startFromForUsec64(from_us, 0);
+    }
+    inline void startFor(const double for_sec)
+    {
+        startFromForUsec64(0, for_sec * 1000000.);
+    }
+    inline void startForMsec(const double for_ms)
+    {
+        startFromForUsec64(0, for_ms * 1000.);
+    }
+    inline void startForUsec(const double for_us)
+    {
+        startFromForUsec64(0, for_us);
+    }
+    inline void startFromFor(const double from_sec, const double for_sec)
+    {
+        startFromForUsec64(from_sec * 1000000., for_sec * 1000000.);
+    }
+    inline void startFromForMsec(const double from_ms, const double for_ms)
+    {
+        startFromForUsec64(from_ms * 1000., for_ms * 1000.);
+    }
+    inline void startFromForUsec(const double from_us, const double for_us)
+    {
+        startFromForUsec64(from_us, for_us);
+    }
+    inline void startFromForUsec64(const int64_t from_us, const int64_t for_us)
+    {
+        running = true;
+        prev_running = false;
+        prev_us32 = MICROS();
+        origin = prev_us64 = (int64_t)prev_us32;
+        ovf = 0;
+        offset = from_us;
+        duration = for_us;
+    }
+
+    inline void stop()
+    {
+        running = false;
+        prev_running = false;
+        prev_us32 = 0;
+        origin = prev_us64 = 0;
+        ovf = 0;
+        offset = 0;
+        duration = 0;
+    }
+
+    inline void play()
+    {
+        if (isPausing())
+        {
+            running = true;
+            const uint32_t curr_us32 = MICROS();
+            int64_t diff = 0;
+            if (curr_us32 > prev_us32)
+                diff = (int64_t)(curr_us32 - prev_us32);
+            else
+                diff = UINT32_NUMERIC_LIMIT_MAX - (int64_t)(prev_us32 - curr_us32);
+            origin += diff;
+            prev_us64 += diff;
+            prev_us32 = curr_us32;
+        }
+        else if (isRunning())
+            ;
+        else
+            restart();
+    }
+
+    inline void pause()
+    {
+        if (isRunning())
+        {
+            microsec();
+            running = false;
+        }
+    }
+
+    inline void restart()
+    {
+        stop();
+        start();
+    }
+
+    inline bool isRunning() const { return running; }
+    inline bool isPausing() const { return (!running && (origin != 0)); }
+    inline bool isStopping() const { return (!running && (origin == 0)); }
+
+    inline bool hasStarted() const { return running && !prev_running; }
+    inline bool hasFinished() const { return !running && prev_running; }
+
+    inline int64_t usec64() { return microsec(); }
+    inline double usec() { return (double)microsec(); }
+    inline double msec() { return usec() * 0.001; }
+    inline double sec() { return usec() * 0.000001; }
+
+    inline double getOrigin() const { return (double)origin; }
+    inline uint32_t getOverflow() const { return ovf; }
+    inline double getOffset() const { return offset; }
+    inline double getDuration() const { return duration; }
+    inline double getRemainingTime() { return (double)duration - usec(); }
+    inline double getRemainingLife() { return (double)duration - usec() / (double)duration; }
+
+    inline void setOffsetUsec(const int64_t us) { offset = us; }
+    inline void setOffsetMsec(const double ms) { setOffsetUsec(int64_t(1000. * ms)); }
+    inline void setOffsetSec(const double sec) { setOffsetUsec(int64_t(1000000. * sec)); }
+
+    inline void addOffsetUsec(const int64_t us) { setOffsetUsec(offset + us); }
+    inline void addOffsetMsec(const double ms) { addOffsetUsec(int64_t(1000. * ms)); }
+    inline void addOffsetSec(const double sec) { addOffsetUsec(int64_t(1000000. * sec)); }
+
+    inline void setTimeUsec(const int64_t u)
+    {
+        if (isStopping())
+        {
+            prev_us32 = MICROS();
+            prev_us64 = (int64_t)prev_us32;
+            origin = prev_us64 - u;
+            offset = 0;
+        }
+        else if (isPausing())
+        {
+            int64_t diff_us = (int64_t)MICROS() - (int64_t)prev_us32;
+            if (diff_us >= 0)
+            {
+                // overflow
+                if ((int64_t)UINT32_NUMERIC_LIMIT_MAX - (int64_t)prev_us32 < diff_us)
+                {
+                    prev_us32 += (uint32_t)diff_us; // overflow
+                    ++ovf;
+                }
+                else
+                {
+                    prev_us32 += (uint32_t)diff_us;
+                }
+            }
+            // overflow
+            else
+            {
+                diff_us = (int64_t)MICROS() + ((int64_t)UINT32_NUMERIC_LIMIT_MAX - (int64_t)prev_us32);
+                prev_us32 += (uint32_t)diff_us; // overflow
+                ++ovf;
+            }
+            prev_us64 += diff_us;
+            origin += diff_us;
+            setOffsetUsec(u - elapsed());
+        }
+        else // isRunning()
+        {
+            setOffsetUsec(u - elapsed());
+        }
+    }
+    inline void setTimeMsec(const double m) { setTimeUsec(int64_t(m * 1000.)); }
+    inline void setTimeSec(const double s) { setTimeUsec(int64_t(s * 1000000.)); }
+
+
+protected:
+
+    inline int64_t microsec()
+    {
+        if (isStopping()) return 0;
+        if (isPausing())
+        {
+            if (hasFinished()) prev_running = false;
+            return prev_us64 - origin + offset;
+        }
+
+        int64_t t = elapsed() + offset;
+        if ((t >= duration) && (duration != 0))
+        {
+            running = false;
+            return prev_us64 - origin + offset;
+        }
+        prev_running = isRunning();
+
+        return t;
+    }
+
+    inline int64_t elapsed()
+    {
+        uint32_t curr_us32 = MICROS();
+
+        if (curr_us32 < prev_us32) // check overflow and interrupt
+        {
+            if (MICROS() < prev_us32) // overflow
+            {
+                if (prev_us32 - MICROS() > UINT32_NUMERIC_LIMIT_HALF)
+                    ++ovf;
+            }
+            else // interrupted and changed prev_us after curr_us is captured
+            {
+                curr_us32 = MICROS(); // update curr_us
+            }
+        }
+        prev_us32 = curr_us32;
+        const int64_t now = (int64_t)curr_us32 | ((int64_t)ovf << 32);
+        prev_us64 = now;
+        return now - origin;
+    }
+};
+
+#endif // HT_POLLINGTIMER_H
diff --git a/Tween/util/PollingTimer/README.md b/Tween/util/PollingTimer/README.md
new file mode 100644
index 0000000..17d66c2
--- /dev/null
+++ b/Tween/util/PollingTimer/README.md
@@ -0,0 +1,217 @@
+# PollingTimer
+
+Arduino library to manage timing and event in a flexible way with polling
+
+
+## Feature
+
+- Four timers based on the situation
+  - `PollingTimer`
+  - `IntervalCounter`
+  - `FrameRateCounter`
+  - `OneShotTimer`
+- Timer events with callback / lambda
+- 64bit support
+
+
+## Usage
+
+### `PollingTimer`
+
+``` C++
+#include <PollingTimer.h>
+PollingTimer timer;
+
+void setup()
+{
+    Serial.begin(115200);
+    timer.start();
+}
+
+void loop()
+{
+    if (timer.isRunning())
+    {
+        Serial.println(timer.msec());
+    }
+}
+```
+
+### `IntervalCounter`
+
+``` C++
+#include <IntervalCounter.h>
+IntervalCounter interval(1.0); // interval is 1.0[sec]
+
+void setup()
+{
+    interval.addEvent([&]()
+    {
+        Serial.print("interval count = ");
+        Serial.print(interval.count());
+        Serial.print(", time = ");
+        Serial.println(interval.ms());
+    });
+
+    interval.start();
+}
+
+void loop()
+{
+    interval.update(); // event occurs if interval is changed
+}
+```
+
+### `FrameRateCounter`
+
+``` C++
+#include <FrameRateCounter.h>
+FrameRateCounter fps(30); // set framrate to 30[Hz]
+
+void setup()
+{
+    fps.addEvent([&]()
+    {
+        Serial.print("frame no. = ");
+        Serial.print(fps.frame());
+        Serial.print(", time = ");
+        Serial.println(fps.msec());
+    });
+
+    fps.start();
+}
+
+void loop()
+{
+    fps.update(); // event occurs if fram has changed
+}
+```
+
+### `OneShotTimer`
+
+``` C++
+#include <OneShotTimer.h>
+OneShotTimer onshot(5); // event will be
+
+void setup()
+{
+    oneshot.addEvent([&]()
+    {
+        Serial.print("oneshot event, time = ");
+        Serial.println(millis());
+    });
+
+    oneshot.start();
+}
+
+void loop()
+{
+    oneshot.update(); // event occurs only once if time has elapsed
+}
+```
+
+
+## PollingTimer States Transition
+
+![](resources/pollingtimer_states.jpg)
+
+
+## APIs
+
+### `PollingTimer` (also available on all timer)
+
+``` C++
+void start();
+void startFrom(const double from_sec);
+void startFromMsec(const double from_ms);
+void startFromUsec(const double from_us);
+void startFor(const double for_sec);
+void startForMsec(const double for_ms);
+void startForUsec(const double for_us);
+void startFromFor(const double from_sec, const double for_sec);
+void startFromForMsec(const double from_ms, const double for_ms);
+void startFromForUsec(const double from_us, const double for_us);
+void startFromForUsec64(const int64_t from_us, const int64_t for_us);
+
+void stop();
+void play();
+void pause();
+void restart();
+
+bool isRunning() const;
+bool isPausing() const;
+bool isStopping() const;
+
+bool hasStarted() const;
+bool hasFinished() const;
+
+int64_t usec64();
+double usec();
+double msec();
+double sec();
+
+double getOrigin() const;
+uint32_t getOverflow() const;
+double getOffset() const;
+double getDuration() const;
+double getRemainingTime();
+double getRemainingLife();
+
+void setOffsetUsec(const int64_t us);
+void setOffsetMsec(const double ms);
+void setOffsetSec(const double sec);
+
+void addOffsetUsec(const int64_t us);
+void addOffsetMsec(const double ms);
+void addOffsetSec(const double sec);
+
+void setTimeUsec(const int64_t u);
+void setTimeMsec(const double m) { setTimeUsec(int64_t(m * 1000.)); }
+void setTimeSec(const double s) { setTimeUsec(int64_t(s * 1000000.)); }
+```
+
+### `IntervalCounter`  (also available on `FrameRateCounter` & `OneShotTimer`)
+
+``` C++
+explicit IntervalCounter (const double sec);
+void startForCount(const double duration_count = 0.);
+bool update();
+double count();
+void setInterval(const double interval_sec);
+void setOffsetCount(const double offset);
+void addEvent(const std::function<void(void)>& f);
+bool hasEvent() const;
+```
+
+### `FrameRateCounter` only
+
+``` C++
+explicit FrameRateCounter(const double fps);
+double frame();
+void setFrameRate(const double rate);
+void setFirstFrameToOne(const bool b);
+double getFrameRate() const;
+bool isFristFrameOne() const;
+```
+
+### `OneShotTimer` only
+
+``` C++
+explicit OneShotTimer(const double sec);
+OneShotTimer(const double sec, const std::function<void(void)>& f);
+```
+
+## Embedded Libraries
+
+- [ArxTypeTraits v0.1.11](https://github.com/hideakitai/ArxTypeTraits)
+- [TeensyDirtySTLErrorSolution v0.1.0](https://github.com/hideakitai/TeensyDirtySTLErrorSolution)
+
+
+## Used Inside Of
+
+- coming soon
+
+
+## License
+
+MIT
diff --git a/Tween/util/PollingTimer/examples/EventCallbacks/EventCallbacks.ino b/Tween/util/PollingTimer/examples/EventCallbacks/EventCallbacks.ino
new file mode 100644
index 0000000..85ee88b
--- /dev/null
+++ b/Tween/util/PollingTimer/examples/EventCallbacks/EventCallbacks.ino
@@ -0,0 +1,32 @@
+#include <IntervalCounter.h>
+#include <FrameRateCounter.h>
+
+IntervalCounter interval(1);
+FrameRateCounter fps(2);
+
+void setup()
+{
+    Serial.begin(115200);
+    delay(5000);
+
+    interval.addEvent([]()
+    {
+        Serial.print("IntervalCounter Event: curr time = ");
+        Serial.println(millis());
+    });
+
+    fps.addEvent([]()
+    {
+        Serial.print("FrameRateCounter Event: curr time = ");
+        Serial.println(millis());
+    });
+
+    interval.start();
+    fps.start();
+}
+
+void loop()
+{
+    interval.update();
+    fps.update();
+}
diff --git a/Tween/util/PollingTimer/examples/FrameRateCounter/FrameRateCounter.ino b/Tween/util/PollingTimer/examples/FrameRateCounter/FrameRateCounter.ino
new file mode 100644
index 0000000..ea78fc2
--- /dev/null
+++ b/Tween/util/PollingTimer/examples/FrameRateCounter/FrameRateCounter.ino
@@ -0,0 +1,24 @@
+#include <FrameRateCounter.h>
+
+FrameRateCounter fps(1);
+
+void setup()
+{
+    Serial.begin(115200);
+    delay(5000);
+
+    fps.start();
+}
+
+void loop()
+{
+    if (fps.update())
+    {
+        Serial.print("frame no. = ");
+        Serial.print(fps.frame());
+        Serial.print(", time = ");
+        Serial.println(fps.msec());
+
+        if (fps.frame() >= 10) fps.restart();
+    }
+}
diff --git a/Tween/util/PollingTimer/examples/IntervalCounter/IntervalCounter.ino b/Tween/util/PollingTimer/examples/IntervalCounter/IntervalCounter.ino
new file mode 100644
index 0000000..2dc8d5d
--- /dev/null
+++ b/Tween/util/PollingTimer/examples/IntervalCounter/IntervalCounter.ino
@@ -0,0 +1,23 @@
+#include <IntervalCounter.h>
+IntervalCounter interval(1.0); // interval is 1.0[sec]
+
+void setup()
+{
+    Serial.begin(115200);
+    delay(5000);
+
+    interval.start();
+}
+
+void loop()
+{
+    if (interval.update())
+    {
+        Serial.print("interval count = ");
+        Serial.print(interval.count());
+        Serial.print(", time = ");
+        Serial.println(interval.msec());
+
+        if (interval.count() >= 10) interval.restart();
+    }
+}
diff --git a/Tween/util/PollingTimer/examples/OneShotTimerEvent/OneShotTimerEvent.ino b/Tween/util/PollingTimer/examples/OneShotTimerEvent/OneShotTimerEvent.ino
new file mode 100644
index 0000000..bb22287
--- /dev/null
+++ b/Tween/util/PollingTimer/examples/OneShotTimerEvent/OneShotTimerEvent.ino
@@ -0,0 +1,24 @@
+#include <OneShotTimer.h>
+
+OneShotTimer oneshot(5);
+
+void setup()
+{
+    Serial.begin(115200);
+    delay(5000);
+
+    oneshot.addEvent([]()
+    {
+        Serial.print("OneShot Event: curr time = ");
+        Serial.println(millis());
+    });
+
+    Serial.print("OneShot Start: curr time = ");
+    Serial.println(millis());
+    oneshot.start();
+}
+
+void loop()
+{
+    oneshot.update();
+}
diff --git a/Tween/util/PollingTimer/examples/PollingTimer/PollingTimer.ino b/Tween/util/PollingTimer/examples/PollingTimer/PollingTimer.ino
new file mode 100644
index 0000000..37ebd20
--- /dev/null
+++ b/Tween/util/PollingTimer/examples/PollingTimer/PollingTimer.ino
@@ -0,0 +1,26 @@
+#include <PollingTimer.h>
+
+PollingTimer timer;
+
+void setup()
+{
+    Serial.begin(115200);
+    delay(5000);
+
+    timer.start();
+}
+
+void loop()
+{
+    if (timer.isRunning())
+    {
+        Serial.print("millis() : ");
+        Serial.print(millis());
+        Serial.print(", timer : ");
+        Serial.println(timer.msec());
+    }
+
+    delay(500);
+
+    if (timer.msec() > 5000) timer.restart();
+}
diff --git a/Tween/util/PollingTimer/examples/PollingTimerOffset/PollingTimerOffset.ino b/Tween/util/PollingTimer/examples/PollingTimerOffset/PollingTimerOffset.ino
new file mode 100644
index 0000000..d930026
--- /dev/null
+++ b/Tween/util/PollingTimer/examples/PollingTimerOffset/PollingTimerOffset.ino
@@ -0,0 +1,30 @@
+#include <PollingTimer.h>
+
+PollingTimer timer;
+
+void setup()
+{
+    Serial.begin(115200);
+    delay(5000);
+
+    timer.start();
+}
+
+void loop()
+{
+    if (timer.isRunning())
+    {
+        Serial.print("millis() : ");
+        Serial.print(millis());
+        Serial.print(", timer : ");
+        Serial.println(timer.msec());
+    }
+
+    delay(500);
+
+    if (timer.msec() > 5000)
+    {
+        timer.setTimeSec(0); // set current time to 0sec
+        Serial.println("time is set to 0sec");;
+    }
+}
diff --git a/Tween/util/PollingTimer/library.json b/Tween/util/PollingTimer/library.json
new file mode 100644
index 0000000..74678b7
--- /dev/null
+++ b/Tween/util/PollingTimer/library.json
@@ -0,0 +1,20 @@
+{
+    "name": "PollingTimer",
+    "keywords": "timing, framerate, timer, fps",
+    "description": "Arduino library to manage timing and event in a flexible way with polling",
+    "repository":
+    {
+        "type": "git",
+        "url": "https://github.com/hideakitai/PollingTimer.git"
+    },
+    "authors":
+    {
+        "name": "Hideaki Tai",
+        "url": "https://github.com/hideakitai",
+        "maintainer": true
+    },
+    "version": "0.2.0",
+    "license": "MIT",
+    "frameworks": "*",
+    "platforms": "*"
+}
diff --git a/Tween/util/PollingTimer/library.properties b/Tween/util/PollingTimer/library.properties
new file mode 100644
index 0000000..64df5dc
--- /dev/null
+++ b/Tween/util/PollingTimer/library.properties
@@ -0,0 +1,9 @@
+name=PollingTimer
+version=0.2.0
+author=hideakitai
+maintainer=hideakitai
+sentence=Arduino library to manage timing and event in a flexible way with polling
+paragraph=Arduino library to manage timing and event in a flexible way with polling
+category=Timing
+url=https://github.com/hideakitai
+architectures=*
diff --git a/Tween/util/PollingTimer/resources/pollingtimer_states.drawio b/Tween/util/PollingTimer/resources/pollingtimer_states.drawio
new file mode 100644
index 0000000..7a158a0
--- /dev/null
+++ b/Tween/util/PollingTimer/resources/pollingtimer_states.drawio
@@ -0,0 +1 @@
+<mxfile host="Electron" modified="2020-06-22T04:01:23.751Z" agent="5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) draw.io/13.0.3 Chrome/80.0.3987.163 Electron/8.2.1 Safari/537.36" etag="Z9LDcGIe5el9QrJVwUGo" version="13.0.3" type="device"><diagram id="ZOOwPItV-tYVI8BX-b5D" name="Page-1">5VjRbtMwFP2aSvAAauI2pY9bN4YQk4AibeMFebWbGFzfyHHWlq/nOnWauMlGkbamG0/zPb524nPuuc7aI5PF6kLTNLkExmUv7LNVj5z1wjDov4vwj0XWG2QcOSDWgrmkCpiK37xc6dBcMJ55iQZAGpH64AyU4jPjYVRrWPppc5D+U1Ma8wYwnVHZRK8EM4lDo+GgmvjARZyUjw6i8WZmQctsd5QsoQyWNYic98hEA5jNaLGacGnZK4nZrHt/z+z2zTRXZp8F3xL2/SS5nSjgXzS7/Hh1Mfvxxh0jM+vyxJwhAS4EbRKIQVF5XqGnGnLFuN21j1GV8wkgRTBA8Cc3Zu3UpLkBhBKzkG6Wr4S5ro1v7FZvw6ELz1Zu6yJYl4Eyen1dD+rLbFytK6Jy4eaE9lj3EuegDHI94w+wVVYg1TE3D+SFW3nRGBwWHN8H12kuqRF3/ntQV6HxNq/SEAdOxn+Q1O17R2XunjQ1kKZCxQ2tfSWXiTB8mtKCgiX62VfNbcu14auHmWye3C3YesF1AxK5eFnzVpmT1GxV5j06We+6rP++V/+jPes/8Ot/dMD6D/es/3uq4ED1TzrVtNLxpjb1/DUlXWoaNnra11ypY2hp0eDYWloQPsM7vXaNb21zmPonz+JO7/Q7zb+n9pb02BXt9JYijY72mebZMXS0AVqx3tGGQdcdbdjgKkNxzavX9lySru1ghzQ8vvGZyYyGX3wCEjQiCpS1yFxIuQNRKWKF4Qzp4oifWjIF/kd44iYWgrHCX21S+GI9hhrDnftl2FRj1CJG+FRijFvEgPR/kmDQYoiDShC0GWKjQSQt57caR7EpKC+N0iMnhT4Y23eaW2Zt/ETaST43nSsXjneUa/s4Iy3SkSeTrmmfl97BovDvIgwOaZ9y47oGePfyNv/gt0CaIRthn+UaPwtAvVSvjAZ7eKX/ODphWP3uWczVfj4m538A</diagram></mxfile>
\ No newline at end of file
diff --git a/Tween/util/PollingTimer/resources/pollingtimer_states.jpg b/Tween/util/PollingTimer/resources/pollingtimer_states.jpg
new file mode 100644
index 0000000..93bbb7d
Binary files /dev/null and b/Tween/util/PollingTimer/resources/pollingtimer_states.jpg differ
diff --git a/Tween/util/PollingTimer/util/ArxTypeTraits/ArxTypeTraits.h b/Tween/util/PollingTimer/util/ArxTypeTraits/ArxTypeTraits.h
new file mode 100644
index 0000000..717cd52
--- /dev/null
+++ b/Tween/util/PollingTimer/util/ArxTypeTraits/ArxTypeTraits.h
@@ -0,0 +1,27 @@
+#pragma once
+
+#ifndef ARX_TYPE_TRAITS_H
+#define ARX_TYPE_TRAITS_H
+
+#if defined(ARDUINO_ARCH_AVR)\
+ || defined(ARDUINO_ARCH_MEGAAVR)\
+ || defined(ARDUINO_ARCH_SAMD)\
+ || defined(ARDUINO_spresense_ast)
+    #define ARX_TYPE_TRAITS_DISABLED
+    #if defined(ARDUINO_ARCH_MEGAAVR)\
+    || defined(ARDUINO_ARCH_SAMD)\
+    || defined(ARDUINO_spresense_ast)
+        #define ARX_TYPE_TRAITS_NEW_DISABLED
+    #endif
+#endif
+
+#include <stddef.h>
+#ifndef ARX_TYPE_TRAITS_DISABLED
+    #include <type_traits>
+    #include <tuple>
+    #include <functional>
+#endif
+
+#include "ArxTypeTraits/type_traits.h"
+
+#endif // ARX_TYPE_TRAITS_H
diff --git a/Tween/util/PollingTimer/util/ArxTypeTraits/ArxTypeTraits/functional.h b/Tween/util/PollingTimer/util/ArxTypeTraits/ArxTypeTraits/functional.h
new file mode 100644
index 0000000..ed1ff17
--- /dev/null
+++ b/Tween/util/PollingTimer/util/ArxTypeTraits/ArxTypeTraits/functional.h
@@ -0,0 +1,149 @@
+#pragma once
+
+#ifndef ARX_TYPE_TRAITS_FUNCTIONAL_H
+#define ARX_TYPE_TRAITS_FUNCTIONAL_H
+
+#include <Arduino.h>
+
+#ifdef ARX_TYPE_TRAITS_NEW_DISABLED
+    void* operator new (const size_t size, void* ptr) { (void)size; return ptr; }
+#else
+    #include <new.h>
+#endif
+
+#ifdef ARX_TYPE_TRAITS_DISABLED
+
+namespace std {
+
+    // reference:
+    // stack overflow https://stackoverflow.com/questions/32074410/stdfunction-bind-like-type-erasure-without-standard-c-library
+
+    template<class Signature>
+    struct function;
+
+    template<class R, class... Args>
+    class function<R(Args...)>
+    {
+        struct vtable_t
+        {
+            void (*mover)(void* src, void* dest);
+            void (*destroyer)(void*);
+            R (*invoke)(void const* t, Args&&... args);
+
+            template <class T>
+            static vtable_t const* get()
+            {
+                static const vtable_t table =
+                {
+                    // mover
+                    [] (void* src, void* dest)
+                    {
+                        new(dest) T(move(*static_cast<T*>(src)));
+                    },
+                    // destroyer
+                    [] (void* t)
+                    {
+                        static_cast<T*>(t)->~T();
+                    },
+                    // invoke
+                    [] (void const* t, Args&&... args) -> R
+                    {
+                        return (*static_cast<T const*>(t))(std::forward<Args>(args)...);
+                    }
+                };
+                return &table;
+            }
+        };
+
+        vtable_t const* table {nullptr};
+        void* data {nullptr};
+
+    public:
+
+        template <
+            class Func,
+            class dF = typename std::decay<Func>::type,
+            typename enable_if <!std::is_same<dF, function>{}>::type* = nullptr,
+            typename enable_if <std::is_convertible<typename result_of<dF&(Args...)>::type, R>{}>::type* = nullptr
+        >
+        function(const Func& f)
+        : table(vtable_t::template get<dF>())
+        {
+            data = reinterpret_cast<void*>(new Func(f));
+        }
+        function(const function& o)
+        : table(o.table)
+        {
+            data = o.data;
+        }
+        function(function&& o)
+        : table(o.table)
+        {
+            if (table) table->mover(o.data, data);
+        }
+        function()
+        {
+        }
+        ~function()
+        {
+            if (table) table->destroyer(data);
+        }
+
+        function& operator= (const function& o)
+        {
+            this->~function();
+            new(this) function(move(o));
+            return *this;
+        }
+        function& operator= (function&& o)
+        {
+            this->~function();
+            new(this) function(move(o));
+            return *this;
+        }
+        function& operator= (std::nullptr_t p)
+        {
+            (void)p;
+            this->~function();
+            return *this;
+        }
+
+        explicit operator bool() const
+        {
+            return table;
+        }
+
+        R operator()(Args...args) const
+        {
+            return table->invoke(data, forward<Args>(args)...);
+        }
+    };
+
+    template<class R, class... Args>
+    inline bool operator== (const function<R(Args...)>& f, std::nullptr_t)
+    {
+        return !static_cast<bool>(f);
+    }
+
+    template<class R, class... Args>
+    inline bool operator== (std::nullptr_t, const function<R(Args...)>& f)
+    {
+        return !static_cast<bool>(f);
+    }
+
+    template<class R, class... Args>
+    inline bool operator!= (const function<R(Args...)>& f, std::nullptr_t)
+    {
+        return static_cast<bool>(f);
+    }
+
+    template<class R, class... Args>
+    inline bool operator!= (std::nullptr_t, const function<R(Args...)>& f)
+    {
+        return static_cast<bool>(f);
+    }
+
+} // namespace std
+
+#endif // ARX_TYPE_TRAITS_DISABLED
+#endif // ARX_TYPE_TRAITS_FUNCTIONAL_H
diff --git a/Tween/util/PollingTimer/util/ArxTypeTraits/ArxTypeTraits/tuple.h b/Tween/util/PollingTimer/util/ArxTypeTraits/ArxTypeTraits/tuple.h
new file mode 100644
index 0000000..f8d765b
--- /dev/null
+++ b/Tween/util/PollingTimer/util/ArxTypeTraits/ArxTypeTraits/tuple.h
@@ -0,0 +1,77 @@
+#pragma once
+
+#ifndef ARX_TYPE_TRAITS_TUPLE_H
+#define ARX_TYPE_TRAITS_TUPLE_H
+
+#ifdef ARX_TYPE_TRAITS_DISABLED
+
+namespace std {
+
+    // https://theolizer.com/cpp-school2/cpp-school2-15/
+    // https://wandbox.org/permlink/C0BWIzjqg4iO3kKZ
+
+    template<typename... Ts>
+    struct tuple
+    {
+        tuple() {}
+    };
+
+    template<typename tFirst, typename... tRest>
+    class tuple<tFirst, tRest...> : public tuple<tRest...>
+    {
+        template<size_t N, typename... tTypes> friend struct get_helper;
+        tFirst  mMember;
+    public:
+        tuple(tFirst const& iFirst, tRest const&... iRest)
+        : tuple<tRest...>(iRest...)
+        , mMember(iFirst)
+        { }
+        constexpr tuple() {}
+    };
+
+    template<size_t N, typename... tTypes>
+    struct get_helper { };
+    template<typename tFirst, typename... tRest>
+    struct get_helper<0, tFirst, tRest...>
+    {
+        typedef tFirst type;
+        static type& get(tuple<tFirst, tRest...>& iTuple)
+        {
+            return iTuple.mMember;
+        }
+    };
+    template<size_t N, typename tFirst, typename... tRest>
+    struct get_helper<N, tFirst, tRest...>
+    {
+        typedef typename get_helper<N - 1, tRest...>::type type;
+        static type& get(tuple<tFirst, tRest...>& iTuple)
+        {
+            return get_helper<N - 1, tRest...>::get(iTuple);
+        }
+    };
+
+    template<size_t N, typename... tTypes>
+    typename get_helper<N, tTypes...>::type& get(tuple<tTypes...>& iTuple)
+    {
+        return get_helper<N, tTypes...>::get(iTuple);
+    }
+
+    template <class T> class tuple_size;
+    template <class T> class tuple_size<const T>;
+    template <class T> class tuple_size<volatile T>;
+    template <class T> class tuple_size<const volatile T>;
+    template <class... Types>
+    class tuple_size <tuple<Types...>>
+    : public integral_constant <size_t, sizeof...(Types)> {};
+
+    template <class... Types>
+    auto make_tuple(Types&&... args)
+    -> std::tuple<typename std::remove_reference<Types>::type...>
+    {
+        return std::tuple<typename std::remove_reference<Types>::type...>(std::forward<typename std::remove_reference<Types>::type>(args)...);
+    }
+
+} // namespace std
+
+#endif // ARX_TYPE_TRAITS_DISABLED
+#endif // ARX_TYPE_TRAITS_TUPLE_H
diff --git a/Tween/util/PollingTimer/util/ArxTypeTraits/ArxTypeTraits/type_traits.h b/Tween/util/PollingTimer/util/ArxTypeTraits/ArxTypeTraits/type_traits.h
new file mode 100644
index 0000000..05784e3
--- /dev/null
+++ b/Tween/util/PollingTimer/util/ArxTypeTraits/ArxTypeTraits/type_traits.h
@@ -0,0 +1,626 @@
+#pragma once
+
+#ifndef ARX_TYPE_TRAITS_TYPE_TRAITS_H
+#define ARX_TYPE_TRAITS_TYPE_TRAITS_H
+
+#ifdef ARX_TYPE_TRAITS_DISABLED
+
+#ifdef max
+    #undef max
+    template <typename T1, typename T2>
+    constexpr auto max(T1 x, T2 y)
+    -> decltype(x + y)
+    {
+        return (x > y) ? x : y;
+    }
+#endif
+#ifdef min
+    #undef min
+    template <typename T1, typename T2>
+    constexpr auto min(T1 x, T2 y)
+    -> decltype(x + y)
+    {
+        return (x < y) ? x : y;
+    }
+#endif
+
+#include <stddef.h>
+#include <float.h>
+#include <limits.h>
+
+namespace std {
+
+    using nullptr_t = decltype(nullptr);
+
+    // numeric_limits
+
+    template <typename T>
+    struct numeric_limits
+    {
+        static constexpr T max() { return T(); }
+        static constexpr T min() { return T(); }
+    };
+    template <> constexpr bool numeric_limits<bool>::max() { return true; }
+    template <> constexpr char numeric_limits<char>::max() { return CHAR_MAX; }
+    template <> constexpr signed char numeric_limits<signed char>::max() { return SCHAR_MAX; }
+    template <> constexpr unsigned char numeric_limits<unsigned char>::max() { return UCHAR_MAX; }
+    template <> constexpr wchar_t numeric_limits<wchar_t>::max() { return WCHAR_MAX; }
+    // template <> constexpr char8_t numeric_limits<char8_t>::max() { return UCHAR_MAX; }
+    template <> constexpr char16_t numeric_limits<char16_t>::max() { return UINT_LEAST16_MAX; }
+    template <> constexpr char32_t numeric_limits<char32_t>::max() { return UINT_LEAST32_MAX; }
+    template <> constexpr short numeric_limits<short>::max() { return SHRT_MAX; }
+    template <> constexpr unsigned short numeric_limits<unsigned short>::max() { return USHRT_MAX; }
+    template <> constexpr int numeric_limits<int>::max() { return INT_MAX; }
+    template <> constexpr unsigned int numeric_limits<unsigned int>::max() { return UINT_MAX; }
+    template <> constexpr long numeric_limits<long>::max() { return LONG_MAX; }
+    template <> constexpr unsigned long numeric_limits<unsigned long>::max() { return ULONG_MAX; }
+    // template <> constexpr long long numeric_limits<long long>::max() { return LLONG_MAX; }
+    // template <> constexpr unsigned long long numeric_limits<unsigned long long>::max() { return ULLONG_MAX; }
+    template <> constexpr float numeric_limits<float>::max() { return FLT_MAX; }
+    template <> constexpr double numeric_limits<double>::max() { return DBL_MAX; }
+    template <> constexpr long double numeric_limits<long double>::max() { return LDBL_MAX; }
+
+    template <> constexpr bool numeric_limits<bool>::min() { return false; }
+    template <> constexpr char numeric_limits<char>::min() { return CHAR_MIN; }
+    template <> constexpr signed char numeric_limits<signed char>::min() { return SCHAR_MIN; }
+    template <> constexpr unsigned char numeric_limits<unsigned char>::min() { return 0; }
+    template <> constexpr wchar_t numeric_limits<wchar_t>::min() { return WCHAR_MIN; }
+    // template <> constexpr char8_t numeric_limits<char8_t>::min() { return 0; }
+    template <> constexpr char16_t numeric_limits<char16_t>::min() { return 0; }
+    template <> constexpr char32_t numeric_limits<char32_t>::min() { return 0; }
+    template <> constexpr short numeric_limits<short>::min() { return SHRT_MIN; }
+    template <> constexpr unsigned short numeric_limits<unsigned short>::min() { return 0; }
+    template <> constexpr int numeric_limits<int>::min() { return INT_MIN; }
+    template <> constexpr unsigned int numeric_limits<unsigned int>::min() { return 0; }
+    template <> constexpr long numeric_limits<long>::min() { return LONG_MIN; }
+    template <> constexpr unsigned long numeric_limits<unsigned long>::min() { return 0; }
+    // template <> constexpr long long numeric_limits<long long>::min() { return LLONG_MIN; }
+    // template <> constexpr unsigned long long numeric_limits<unsigned long long>::min() { return 0; }
+    template <> constexpr float numeric_limits<float>::min() { return FLT_MIN; }
+    template <> constexpr double numeric_limits<double>::min() { return DBL_MIN; }
+    template <> constexpr long double numeric_limits<long double>::min() { return LDBL_MIN; }
+
+
+    // integral_constant
+
+    template<class T, T v>
+    struct integral_constant
+    {
+        static constexpr T value = v;
+        using value_type = T;
+        using type = integral_constant;
+        constexpr operator value_type() const noexcept { return value; }
+        constexpr value_type operator()() const noexcept { return value; }
+    };
+
+    using true_type = integral_constant<bool, true>;
+    using false_type = integral_constant<bool, false>;
+
+
+    template <class T>
+    T declval(); // no implementation
+
+
+    template <bool, typename T = void>
+    struct enable_if;
+    template <typename T>
+    struct enable_if <true, T> { using type = T; };
+
+
+    template<bool, class T, class F>
+    struct conditional { using type = T; };
+    template<class T, class F>
+    struct conditional<false, T, F> { using type = F; };
+
+
+    template <class T> struct remove_cv                   { using type = T; };
+    template <class T> struct remove_cv<const T>          { using type = T; };
+    template <class T> struct remove_cv<volatile T>       { using type = T; };
+    template <class T> struct remove_cv<const volatile T> { using type = T; };
+
+    template <class T> struct remove_const                { using type = T; };
+    template <class T> struct remove_const<const T>       { using type = T; };
+
+    template <class T> struct remove_volatile             { using type = T; };
+    template <class T> struct remove_volatile<volatile T> { using type = T; };
+
+    template <class T> struct remove_pointer                    { using type = T; };
+    template <class T> struct remove_pointer<T*>                { using type = T; };
+    template <class T> struct remove_pointer<T* const>          { using type = T; };
+    template <class T> struct remove_pointer<T* volatile>       { using type = T; };
+    template <class T> struct remove_pointer<T* const volatile> { using type = T; };
+
+    template <class T> struct remove_reference      { using type = T; };
+    template <class T> struct remove_reference<T&>  { using type = T; };
+    template <class T> struct remove_reference<T&&> { using type = T; };
+
+    template<class T> struct remove_extent                 { typedef T type; };
+    template<class T> struct remove_extent<T[]>            { typedef T type; };
+    template<class T, size_t N> struct remove_extent<T[N]> { typedef T type; };
+
+
+    template<class T>
+    T&& move(T& t){ return static_cast<T&&>(t); }
+    template<class T>
+    T&& move(T&& t){ return static_cast<T&&>(t); }
+
+
+    template <class T>
+    constexpr T&& forward(typename remove_reference<T>::type& t) noexcept
+    {
+        return static_cast<T&&>(t);
+    }
+    template <class T>
+    constexpr T&& forward(typename remove_reference<T>::type&& t) noexcept
+    {
+        return static_cast<T&&>(t);
+    }
+
+
+    namespace detail
+    {
+        template <class T>
+        struct type_identity { using type = T; };
+        template <class T>
+        auto try_add_pointer(int) -> type_identity<typename remove_reference<T>::type*>;
+        template <class T>
+        auto try_add_pointer(...) -> type_identity<T>;
+    }
+    template <class T>
+    struct add_pointer : decltype(detail::try_add_pointer<T>(0)) {};
+
+
+    template <typename T, typename U>
+    struct is_same : false_type {};
+    template <typename T>
+    struct is_same <T, T> : true_type {};
+
+
+    template <typename T>
+    struct is_integral : false_type {};
+    template <> struct is_integral <bool> : true_type {};
+    template <> struct is_integral <char> : true_type {};
+    template <> struct is_integral <signed char> : true_type {};
+    template <> struct is_integral <unsigned char> : true_type {};
+    template <> struct is_integral <char16_t> : true_type {};
+    template <> struct is_integral <char32_t> : true_type {};
+    template <> struct is_integral <wchar_t> : true_type {};
+    template <> struct is_integral <short> : true_type {};
+    template <> struct is_integral <unsigned short> : true_type {};
+    template <> struct is_integral <int> : true_type {};
+    template <> struct is_integral <unsigned> : true_type {};
+    template <> struct is_integral <long> : true_type {};
+    template <> struct is_integral <unsigned long> : true_type {};
+    template <> struct is_integral <long long> : true_type {};
+    template <> struct is_integral <unsigned long long> : true_type {};
+
+
+    template <typename T>
+    struct is_floating_point : false_type {};
+    template <> struct is_floating_point<float> : true_type {};
+    template <> struct is_floating_point<double> : true_type {};
+    template <> struct is_floating_point<long double> : true_type {};
+
+
+    template <typename T>
+    struct is_arithmetic
+    : conditional<
+        is_integral<T>::value || is_floating_point<T>::value,
+        true_type,
+        false_type
+    >::type
+    {};
+
+
+    namespace detail
+    {
+        template <typename T, bool = is_arithmetic<T>::value>
+        struct is_signed : integral_constant<bool, T(-1) < T(0)> {};
+        template <typename T>
+        struct is_signed<T, false> : false_type {};
+    }
+    template <typename T>
+    struct is_signed : detail::is_signed<T>::type {};
+
+
+    namespace detail
+    {
+        template<typename T, bool = is_arithmetic<T>::value>
+        struct is_unsigned : integral_constant<bool, T(0) < T(-1)> {};
+        template<typename T>
+        struct is_unsigned<T, false> : false_type {};
+    }
+    template<typename T>
+    struct is_unsigned : detail::is_unsigned<T>::type {};
+
+
+    template <class T> struct is_pointer_helper     : false_type {};
+    template <class T> struct is_pointer_helper<T*> : true_type {};
+    template <class T> struct is_pointer : is_pointer_helper<typename remove_cv<T>::type> {};
+
+
+    template<class T>
+    struct is_array : false_type {};
+    template<class T>
+    struct is_array<T[]> : true_type {};
+    template<class T, size_t N>
+    struct is_array<T[N]> : true_type {};
+
+
+    namespace details
+    {
+        template <class... Ts>
+        struct Tester { using type = void; };
+        template <class... Ts>
+        using void_t = typename Tester<Ts...>::type;
+        template<template<class...>class Z, class, class...Ts>
+        struct can_apply : false_type{};
+        template<template<class...>class Z, class...Ts>
+        struct can_apply<Z, void_t<Z<Ts...>>, Ts...> : true_type{};
+
+        template<class From, class To>
+        using try_convert = decltype(To{declval<From>()} );
+    }
+    template<template<class...>class Z, class...Ts>
+    using can_apply = details::can_apply<Z, void, Ts...>;
+    template<class From, class To>
+    struct is_convertible : can_apply <details::try_convert, From, To> {};
+    template<>
+    struct is_convertible<void,void> : true_type{};
+
+
+    // primary template
+    template<class>
+    struct is_function : false_type { };
+    // specialization for regular functions
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args...)> : true_type {};
+    // specialization for variadic functions such as std::printf
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args......)> : true_type {};
+    // specialization for function types that have cv-qualifiers
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args...) const> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args...) volatile> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args...) const volatile> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args......) const> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args......) volatile> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args......) const volatile> : true_type {};
+    // specialization for function types that have ref-qualifiers
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args...) &> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args...) const &> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args...) volatile &> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args...) const volatile &> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args......) &> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args......) const &> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args......) volatile &> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args......) const volatile &> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args...) &&> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args...) const &&> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args...) volatile &&> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args...) const volatile &&> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args......) &&> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args......) const &&> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args......) volatile &&> : true_type {};
+    template<class Ret, class... Args>
+    struct is_function<Ret(Args......) const volatile &&> : true_type {};
+
+
+    template<typename T>
+    struct is_empty : public integral_constant<bool, __is_empty(T)> { };
+
+
+    template <class T>
+    class decay
+    {
+        typedef typename remove_reference<T>::type U;
+    public:
+        typedef typename conditional<
+            is_array<U>::value,
+            typename remove_extent<U>::type*,
+            typename conditional<
+                is_function<U>::value,
+                typename add_pointer<U>::type,
+                typename remove_cv<U>::type
+            >::type
+        >::type type;
+    };
+
+
+    namespace details
+    {
+        template<class T> struct tag { using type=T; };
+        template<class Tag> using type_t = typename Tag::type;
+
+        template<class G, class...Args>
+        using invoke_t = decltype( declval<G>()(declval<Args>()...) );
+
+        template<class Sig, class = void>
+        struct result_of {};
+        template<class G, class...Args>
+        struct result_of<G(Args...), void_t<invoke_t<G, Args...>>>
+        : tag <invoke_t<G, Args...>>
+        {};
+    }
+    template<class Sig>
+    using result_of = details::result_of<Sig>;
+
+
+    template <class T>
+    void swap(T& a, T& b)
+    {
+        T t = move(a);
+        a = move(b);
+        b = move(t);
+    }
+
+
+#ifndef ARX_TYPE_TRAITS_INITIALIZER_LIST_DEFINED
+#define ARX_TYPE_TRAITS_INITIALIZER_LIST_DEFINED
+
+    template<class T>
+    class initializer_list
+    {
+    private:
+        const T* array;
+        size_t len;
+        initializer_list(const T* a, size_t l) : array(a), len(l) {}
+    public:
+        initializer_list() : array(nullptr), len(0) {}
+        size_t size() const { return len; }
+        const T *begin() const { return array; }
+        const T *end() const { return array + len; }
+    };
+
+#endif // ARX_TYPE_TRAITS_INITIALIZER_LIST_DEFINED
+
+} // namespace std
+
+#include "tuple.h"
+#include "functional.h"
+
+#endif // ARX_TYPE_TRAITS_DISABLE_STL
+
+
+#if __cplusplus < 201402L // C++11
+#if !defined(OF_VERSION_MAJOR) || !defined(TARGET_WIN32)
+
+namespace std {
+
+    template <bool B, typename T = void>
+    using enable_if_t = typename std::enable_if<B, T>::type;
+
+    template <typename T>
+    using decay_t = typename std::decay<T>::type;
+
+    template<class T>
+    using remove_cv_t = typename std::remove_cv<T>::type;
+    template<class T>
+    using remove_const_t = typename std::remove_const<T>::type;
+    template<class T>
+    using remove_volatile_t = typename std::remove_volatile<T>::type;
+    template<class T>
+    using remove_reference_t = typename std::remove_reference<T>::type;
+    template<class T>
+    using remove_pointer_t = typename std::remove_pointer<T>::type;
+
+    template<typename T, T ...Ts>
+    struct integer_sequence
+    {
+        using type = integer_sequence;
+        using value_type = T;
+        static constexpr size_t size() noexcept { return sizeof...(Ts); }
+    };
+    template <size_t ...Is>
+    using index_sequence = integer_sequence<size_t, Is...>;
+
+    // https://stackoverflow.com/questions/17424477/implementation-c14-make-integer-sequence
+
+    template<typename S1, typename S2>
+    struct concat_impl;
+    template<typename S1, typename S2>
+    using concat = typename concat_impl<S1, S2>::type;
+
+    template<size_t... I1, size_t... I2>
+    struct concat_impl <index_sequence<I1...>, index_sequence<I2...>>
+    : index_sequence<I1..., (sizeof...(I1) + I2)...> {};
+    template<size_t N>
+    struct make_index_sequence_impl;
+    template<size_t N>
+    using make_index_sequence = typename make_index_sequence_impl<N>::type;
+    template<size_t N>
+    struct make_index_sequence_impl
+    : concat<make_index_sequence <N/2>, make_index_sequence <N - N/2>> {};
+    template<>
+    struct make_index_sequence_impl <0> : index_sequence<>{};
+    template<>
+    struct make_index_sequence_impl <1> : index_sequence<0>{};
+
+    template<typename... Ts>
+    using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
+
+} // namespace std
+
+#endif // !defined(OF_VERSION_MAJOR) || !defined(TARGET_WIN32)
+#endif // C++11
+
+
+#if __cplusplus < 201703L // C++14
+
+namespace std {
+
+#if !defined(OF_VERSION_MAJOR) || !defined(TARGET_WIN32)
+
+    template <class... Ts>
+    struct Tester { using type = void; };
+    template <class... Ts>
+    using void_t = typename Tester<Ts...>::type;
+
+    template <typename ...Args>
+    struct disjunction : std::false_type {};
+    template <typename Arg>
+    struct disjunction <Arg> : Arg::type {};
+    template <typename Arg, typename ...Args>
+    struct disjunction <Arg, Args...> : std::conditional<Arg::value, Arg, disjunction<Args...>>::type {};
+
+    template <typename ...Args>
+    struct conjunction : std::true_type {};
+    template <typename Arg>
+    struct conjunction <Arg> : Arg::type {};
+    template <typename Arg, typename ...Args>
+    struct conjunction <Arg, Args...> : std::conditional<Arg::value, conjunction<Args...>, Arg>::type {};
+
+    template <typename T>
+    struct negation : std::integral_constant<bool, !T::value> {};
+
+#endif // !defined(OF_VERSION_MAJOR) || !defined(TARGET_WIN32)
+
+    // https://qiita.com/_EnumHack/items/92e6e135174f1f781dbb
+    // without decltype(auto)
+
+    template <class F, class Tuple, size_t... I>
+    constexpr auto apply_impl(F&& f, Tuple&& t, index_sequence<I...>)
+    -> decltype(f(std::get<I>(std::forward<Tuple>(t))...))
+    {
+        return f(std::get<I>(std::forward<Tuple>(t))...);
+    }
+    template <class F, class Tuple>
+    constexpr auto apply(F&& f, Tuple&& t)
+    -> decltype(apply_impl(
+        std::forward<F>(f),
+        std::forward<Tuple>(t),
+        make_index_sequence<std::tuple_size<decay_t<Tuple>>::value>{}
+    ))
+    {
+        return apply_impl(
+            std::forward<F>(f),
+            std::forward<Tuple>(t),
+            make_index_sequence<std::tuple_size<decay_t<Tuple>>::value>()
+        );
+    }
+
+} // namespace std
+
+#endif // C++14
+
+
+// C++17, C++2a
+namespace std {
+
+    template<class T>
+    struct remove_cvref
+    {
+        typedef std::remove_cv_t<std::remove_reference_t<T>> type;
+    };
+
+    template< class T >
+    using remove_cvref_t = typename remove_cvref<T>::type;
+
+} // namespace std
+// C++17, C++2a
+
+
+namespace arx { // others
+
+    template <class AlwaysVoid, template<class...> class Check, class... T>
+    struct is_detected_impl : std::false_type {};
+    template <template <class...> class Check, class... T>
+    struct is_detected_impl <std::void_t<Check<T...>>, Check, T...> : std::true_type {};
+    template <template <class...> class Check, class... T>
+    using is_detected = is_detected_impl<void, Check, T...>;
+
+
+    template <typename T>
+    struct is_callable {
+        template <typename U, decltype(&U::operator()) = &U::operator()>
+        struct checker {};
+        template <typename U> static std::true_type  test(checker<U> *);
+        template <typename>   static std::false_type test(...);
+        static constexpr bool value = decltype(test<T>(nullptr))::value;
+    };
+    template <typename R, typename ... Arguments>
+    struct is_callable<R(*)(Arguments ...)> {
+        static constexpr bool value = true;
+    };
+    template <typename R, typename ... Arguments>
+    struct is_callable<R(*&)(Arguments ...)> {
+        static constexpr bool value = true;
+    };
+    template <typename R, typename ... Arguments>
+    struct is_callable<R(&)(Arguments ...)> {
+        static constexpr bool value = true;
+    };
+    template <typename R, typename ... Arguments>
+    struct is_callable<R(Arguments ...)> {
+        static constexpr bool value = true;
+    };
+    template <typename R, typename ... Arguments>
+    struct is_callable<std::function<R(Arguments ...)>> {
+        static constexpr bool value = true;
+    };
+
+
+    namespace detail {
+        template <typename ret, typename ... arguments>
+        struct function_traits {
+            static constexpr size_t arity = sizeof...(arguments);
+            using result_type = ret;
+            using arguments_types_tuple = std::tuple<arguments ...>;
+            // template <size_t index>
+            // using argument_type = type_at<index, arguments ...>;
+            using function_type = std::function<ret(arguments ...)>;
+            template <typename function_t>
+            static constexpr function_type cast(function_t f) {
+                return static_cast<function_type>(f);
+            }
+        };
+    };
+    template <typename T>
+    struct function_traits : public function_traits<decltype(&T::operator())> {};
+    template <typename class_type, typename ret, typename ... arguments>
+    struct function_traits<ret(class_type::*)(arguments ...) const>
+    : detail::function_traits<ret, arguments ...> {};
+
+    template <typename class_type, typename ret, typename ... arguments>
+    struct function_traits<ret(class_type::*)(arguments ...)>
+    : detail::function_traits<ret, arguments ...> {};
+
+    template <typename ret, typename ... arguments>
+    struct function_traits<ret(*)(arguments ...)>
+    : detail::function_traits<ret, arguments ...> {};
+
+    template <typename ret, typename ... arguments>
+    struct function_traits<ret(*&)(arguments ...)>
+    : detail::function_traits<ret, arguments ...> {};
+
+    template <typename ret, typename ... arguments>
+    struct function_traits<ret(arguments ...)>
+    : detail::function_traits<ret, arguments ...> {};
+
+    template <typename ret, typename ... arguments>
+    struct function_traits<std::function<ret(arguments ...)>>
+    : detail::function_traits<ret, arguments ...> {};
+
+} // namespace arx
+
+#endif // ARX_TYPE_TRAITS_TYPE_TRAITS_H
diff --git a/Tween/util/PollingTimer/util/ArxTypeTraits/LICENSE b/Tween/util/PollingTimer/util/ArxTypeTraits/LICENSE
new file mode 100644
index 0000000..6f5269b
--- /dev/null
+++ b/Tween/util/PollingTimer/util/ArxTypeTraits/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Hideaki Tai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/Tween/util/PollingTimer/util/ArxTypeTraits/README.md b/Tween/util/PollingTimer/util/ArxTypeTraits/README.md
new file mode 100644
index 0000000..a144f4d
--- /dev/null
+++ b/Tween/util/PollingTimer/util/ArxTypeTraits/README.md
@@ -0,0 +1,109 @@
+# ArxTypeTraits
+
+C++ type_traits for Arduino which cannot use it as default
+
+
+## Supported Boards
+
+C++11 class templates of this library is currently enabled only if you use following architecture to avoid conflict with standard `type_traits`.
+
+- AVR (Uno, Nano, Mega, etc.)
+- MEGAAVR (Uno WiFi, Nano Ecery, etc.)
+- SAMD (Zero, MKR, M0, etc.)
+- SPRESENSE
+
+Others are automatically enabled/disabled depending on compiler.
+
+
+## Supported Class Templates
+
+### C++11 (defined only for platforms above which cannot use `type_traits`)
+
+- `std::integral_constant`
+- `std::true_type`
+- `std::false_type`
+- `std::declval`
+- `std::enable_if`
+- `std::conditional`
+- `std::remove_cv`
+- `std::remove_const`
+- `std::remove_volatile`
+- `std::remove_pointer`
+- `std::remove_reference`
+- `std::remove_extent`
+- `std::add_pointer`
+- `std::forward`
+- `std::is_same`
+- `std::is_integral`
+- `std::is_floating_point`
+- `std::is_arithmetic`
+- `std::is_signed`
+- `std::is_unsigned`
+- `std::is_pointer`
+- `std::is_array`
+- `std::is_convertible`
+- `std::is_function`
+- `std::is_empty`
+- `std::decay`
+- `std::result_of`
+
+
+#### for utility
+
+- `std::numeric_limits` (only `max()` and `min()` now)
+- `std::swap`
+- `std::initializer_list`
+- `std::tuple`
+- `std::get`
+- `std::tuple_size`
+- `std::function`
+
+
+### C++14 (defined only for boards before C++14)
+
+- `std::enable_if_t`
+- `std::decay_t`
+- `std::remove_cv_t`
+- `std::remove_const_t`
+- `std::remove_volatile_t`
+- `std::remove_reference_t`
+- `std::remove_pointer_t`
+- `std::integer_sequence`
+- `std::index_sequence`
+- `std::make_index_sequence`
+- `std::index_sequence_for`
+
+
+### C++17 (defined only for boards before C++17)
+
+- `std::void_t`
+- `std::disjunction`
+- `std::conjunction`
+- `std::negation`
+- `std::apply`
+
+
+### C++2a
+
+- `std::remove_cvref`
+- `std::remove_cvref_t`
+
+
+### Others (defined for all boards)
+
+- `arx::is_detected`
+- `arx::is_callable`
+- `arx::function_traits`
+
+
+## Used Inside of
+
+- [Packetizer](https://github.com/hideakitai/Packetizer)
+- [MsgPack](https://github.com/hideakitai/MsgPack)
+- [MsgPacketizer](https://github.com/hideakitai/MsgPacketizer)
+- [ArduinoOSC](https://github.com/hideakitai/ArduinoOSC)
+
+
+## License
+
+MIT
diff --git a/Tween/util/PollingTimer/util/ArxTypeTraits/library.json b/Tween/util/PollingTimer/util/ArxTypeTraits/library.json
new file mode 100644
index 0000000..4be6e75
--- /dev/null
+++ b/Tween/util/PollingTimer/util/ArxTypeTraits/library.json
@@ -0,0 +1,20 @@
+{
+    "name": "ArxTypeTraits",
+    "keywords": "type traits, functional, tuple, stl",
+    "description": "C++ type_traits for Arduino which cannot use it as default",
+    "repository":
+    {
+        "type": "git",
+        "url": "https://github.com/hideakitai/ArxTypeTraits.git"
+    },
+    "authors":
+    {
+        "name": "Hideaki Tai",
+        "url": "https://github.com/hideakitai",
+        "maintainer": true
+    },
+    "version": "0.1.11",
+    "license": "MIT",
+    "frameworks": "arduino",
+    "platforms": "*"
+}
diff --git a/Tween/util/PollingTimer/util/ArxTypeTraits/library.properties b/Tween/util/PollingTimer/util/ArxTypeTraits/library.properties
new file mode 100644
index 0000000..3105b21
--- /dev/null
+++ b/Tween/util/PollingTimer/util/ArxTypeTraits/library.properties
@@ -0,0 +1,9 @@
+name=ArxTypeTraits
+version=0.1.11
+author=hideakitai
+maintainer=hideakitai
+sentence=C++ type_traits for Arduino which cannot use it as default
+paragraph=C++ type_traits for Arduino which cannot use it as default
+category=Data Storage
+url=https://github.com/hideakitai
+architectures=*
diff --git a/Tween/util/PollingTimer/util/TeensyDirtySTLErrorSolution/LICENSE b/Tween/util/PollingTimer/util/TeensyDirtySTLErrorSolution/LICENSE
new file mode 100644
index 0000000..6f5269b
--- /dev/null
+++ b/Tween/util/PollingTimer/util/TeensyDirtySTLErrorSolution/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Hideaki Tai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/Tween/util/PollingTimer/util/TeensyDirtySTLErrorSolution/README.md b/Tween/util/PollingTimer/util/TeensyDirtySTLErrorSolution/README.md
new file mode 100644
index 0000000..166a80f
--- /dev/null
+++ b/Tween/util/PollingTimer/util/TeensyDirtySTLErrorSolution/README.md
@@ -0,0 +1,57 @@
+# TeensyDirtySTLErrorSolution
+
+dirty solution to use STL in teensy
+
+## Introduction
+
+Sometimes we want to use STL on Teensy, but Teensy 3.x in Arduino IDE does not support STL by default. Though STL is enabled on Teensy 4.x, but you have to enable it manually on Teensy 3.x. If you use PlatformIO, you can also use STL on Teensy 3.x.
+
+|             | Teensy 4.x        | Teensy 3.x        |
+| ----------- | ----------------- | ----------------- |
+| PlatformIO  | Almost Compilable | Almost Compilable |
+| Arduino IDE | Almost Compilable | NOT Compilable    |
+
+
+## Enable STL in Arduino IDE
+
+To enable STL on Teensy 3.x using Arduino IDE, add `-lstdc++` to `build flags`, which is defined in `boards.txt`. Many STL can be used by adding this flag. You have to do this procedure every time you upgrade the version of Teensyduino.
+
+| OS      | default location                                                |
+| ------- | --------------------------------------------------------------- |
+| macOS   | `Arduino.app/Contents/Java/hardware/teensy/avr/boards.txt`      |
+| Windows | `C:\Program Files (x86)\Arduino\hardware\teensy\avr\boards.txt` |
+
+
+#### Before
+
+``` boards.txt
+ teensy36.build.flags.libs=-larm_cortexM4lf_math -lm
+ teensy35.build.flags.libs=-larm_cortexM4lf_math -lm
+ teensy31.build.flags.libs=-larm_cortexM4l_math -lm
+```
+
+#### After
+
+``` boards.txt
+ teensy36.build.flags.libs=-larm_cortexM4lf_math -lm -lstdc++
+ teensy35.build.flags.libs=-larm_cortexM4lf_math -lm -lstdc++
+ teensy31.build.flags.libs=-larm_cortexM4l_math -lm -lstdc++
+```
+
+## Do you still have compile error?
+
+Yes, maybe you still have compilation error in both 4.x and 3.x for some STLs... Then you should add this library (header file) to your project. Some dirty solution I found is included in this header file.
+
+``` C++
+#include <TeensyDirtySTLErrorSolution.h>
+```
+
+## Warning
+
+This method is not recommended because STL is not enabled by default... (if you know the reason, please let me know). I am not responsible for any trouble that may occur as a result of the use of this library. Please use at your own risk.  
+
+
+## License
+
+MIT
+
diff --git a/Tween/util/PollingTimer/util/TeensyDirtySTLErrorSolution/TeensyDirtySTLErrorSolution.h b/Tween/util/PollingTimer/util/TeensyDirtySTLErrorSolution/TeensyDirtySTLErrorSolution.h
new file mode 100644
index 0000000..b50c6a3
--- /dev/null
+++ b/Tween/util/PollingTimer/util/TeensyDirtySTLErrorSolution/TeensyDirtySTLErrorSolution.h
@@ -0,0 +1,65 @@
+#pragma once
+
+#include <Arduino.h>
+
+#ifdef TEENSYDUINO
+#ifndef TEENSYDUINO_DIRTY_STL_ERROR_SOLUTION
+#define TEENSYDUINO_DIRTY_STL_ERROR_SOLUTION
+
+
+#if defined(__MK20DX256__) || defined(__MK64FX512__) || defined(__MK66FX1M0__) // TEENSY 3.1/3.2, 3.5, 3.6
+
+extern "C"
+{
+    int _write() { return -1; }
+}
+
+#elif defined(__IMXRT1062__) // TEENSY4.0
+
+extern "C"
+{
+    void *__exidx_start __attribute__((__visibility__ ("hidden")));
+    void *__exidx_end __attribute__((__visibility__ ("hidden")));
+}
+
+#else
+
+    #error NOT SUPPORTED TEENSY VERSION
+
+#endif
+
+
+// ----- template -----
+//
+// #if defined(__MK20DX256__) // TEENSY3.1/3.2
+// #elif defined(__MK64FX512__) // TEENSY3.5
+// #elif defined(__MK66FX1M0__) // TEENSY3.6
+// #elif defined(__IMXRT1062__) // TEENSY4.0
+//
+// extern "C"
+// {
+//     int _getpid() { return -1; }
+//     int _kill(int pid, int sig) { return -1; }
+//     int _write() { return -1; }
+//     void *__exidx_start __attribute__((__visibility__ ("hidden")));
+//     void *__exidx_end __attribute__((__visibility__ ("hidden")));
+//     int _getpid();// { return -1; }
+//     int _kill(int pid, int sig);// { return -1; }
+//     int _write() { return -1; }
+//     void *__exidx_start __attribute__((__visibility__ ("hidden")));
+//     void *__exidx_end __attribute__((__visibility__ ("hidden")));
+// }
+//
+// // copied from https://github.com/gcc-mirror/
+// namespace std
+// {
+//     void __throw_bad_alloc() { _GLIBCXX_THROW_OR_ABORT(bad_alloc()); }
+//     void __throw_length_error(const char* __s __attribute__((unused))) { _GLIBCXX_THROW_OR_ABORT(length_error(_(__s))); }
+//     void __throw_bad_function_call() { _GLIBCXX_THROW_OR_ABORT(bad_function_call()); }
+//     void _Rb_tree_decrement(std::_Rb_tree_node_base* a) {}
+//     void _Rb_tree_insert_and_rebalance(bool, std::_Rb_tree_node_base*, std::_Rb_tree_node_base*, std::_Rb_tree_node_base&) {}
+// }
+
+#endif // TEENSYDUINO_DIRTY_STL_ERROR_SOLUTION
+#endif // TEENSYDUINO
+
diff --git a/Tween/util/TeensyDirtySTLErrorSolution/LICENSE b/Tween/util/TeensyDirtySTLErrorSolution/LICENSE
new file mode 100644
index 0000000..6f5269b
--- /dev/null
+++ b/Tween/util/TeensyDirtySTLErrorSolution/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Hideaki Tai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/Tween/util/TeensyDirtySTLErrorSolution/README.md b/Tween/util/TeensyDirtySTLErrorSolution/README.md
new file mode 100644
index 0000000..166a80f
--- /dev/null
+++ b/Tween/util/TeensyDirtySTLErrorSolution/README.md
@@ -0,0 +1,57 @@
+# TeensyDirtySTLErrorSolution
+
+dirty solution to use STL in teensy
+
+## Introduction
+
+Sometimes we want to use STL on Teensy, but Teensy 3.x in Arduino IDE does not support STL by default. Though STL is enabled on Teensy 4.x, but you have to enable it manually on Teensy 3.x. If you use PlatformIO, you can also use STL on Teensy 3.x.
+
+|             | Teensy 4.x        | Teensy 3.x        |
+| ----------- | ----------------- | ----------------- |
+| PlatformIO  | Almost Compilable | Almost Compilable |
+| Arduino IDE | Almost Compilable | NOT Compilable    |
+
+
+## Enable STL in Arduino IDE
+
+To enable STL on Teensy 3.x using Arduino IDE, add `-lstdc++` to `build flags`, which is defined in `boards.txt`. Many STL can be used by adding this flag. You have to do this procedure every time you upgrade the version of Teensyduino.
+
+| OS      | default location                                                |
+| ------- | --------------------------------------------------------------- |
+| macOS   | `Arduino.app/Contents/Java/hardware/teensy/avr/boards.txt`      |
+| Windows | `C:\Program Files (x86)\Arduino\hardware\teensy\avr\boards.txt` |
+
+
+#### Before
+
+``` boards.txt
+ teensy36.build.flags.libs=-larm_cortexM4lf_math -lm
+ teensy35.build.flags.libs=-larm_cortexM4lf_math -lm
+ teensy31.build.flags.libs=-larm_cortexM4l_math -lm
+```
+
+#### After
+
+``` boards.txt
+ teensy36.build.flags.libs=-larm_cortexM4lf_math -lm -lstdc++
+ teensy35.build.flags.libs=-larm_cortexM4lf_math -lm -lstdc++
+ teensy31.build.flags.libs=-larm_cortexM4l_math -lm -lstdc++
+```
+
+## Do you still have compile error?
+
+Yes, maybe you still have compilation error in both 4.x and 3.x for some STLs... Then you should add this library (header file) to your project. Some dirty solution I found is included in this header file.
+
+``` C++
+#include <TeensyDirtySTLErrorSolution.h>
+```
+
+## Warning
+
+This method is not recommended because STL is not enabled by default... (if you know the reason, please let me know). I am not responsible for any trouble that may occur as a result of the use of this library. Please use at your own risk.  
+
+
+## License
+
+MIT
+
diff --git a/Tween/util/TeensyDirtySTLErrorSolution/TeensyDirtySTLErrorSolution.h b/Tween/util/TeensyDirtySTLErrorSolution/TeensyDirtySTLErrorSolution.h
new file mode 100644
index 0000000..b50c6a3
--- /dev/null
+++ b/Tween/util/TeensyDirtySTLErrorSolution/TeensyDirtySTLErrorSolution.h
@@ -0,0 +1,65 @@
+#pragma once
+
+#include <Arduino.h>
+
+#ifdef TEENSYDUINO
+#ifndef TEENSYDUINO_DIRTY_STL_ERROR_SOLUTION
+#define TEENSYDUINO_DIRTY_STL_ERROR_SOLUTION
+
+
+#if defined(__MK20DX256__) || defined(__MK64FX512__) || defined(__MK66FX1M0__) // TEENSY 3.1/3.2, 3.5, 3.6
+
+extern "C"
+{
+    int _write() { return -1; }
+}
+
+#elif defined(__IMXRT1062__) // TEENSY4.0
+
+extern "C"
+{
+    void *__exidx_start __attribute__((__visibility__ ("hidden")));
+    void *__exidx_end __attribute__((__visibility__ ("hidden")));
+}
+
+#else
+
+    #error NOT SUPPORTED TEENSY VERSION
+
+#endif
+
+
+// ----- template -----
+//
+// #if defined(__MK20DX256__) // TEENSY3.1/3.2
+// #elif defined(__MK64FX512__) // TEENSY3.5
+// #elif defined(__MK66FX1M0__) // TEENSY3.6
+// #elif defined(__IMXRT1062__) // TEENSY4.0
+//
+// extern "C"
+// {
+//     int _getpid() { return -1; }
+//     int _kill(int pid, int sig) { return -1; }
+//     int _write() { return -1; }
+//     void *__exidx_start __attribute__((__visibility__ ("hidden")));
+//     void *__exidx_end __attribute__((__visibility__ ("hidden")));
+//     int _getpid();// { return -1; }
+//     int _kill(int pid, int sig);// { return -1; }
+//     int _write() { return -1; }
+//     void *__exidx_start __attribute__((__visibility__ ("hidden")));
+//     void *__exidx_end __attribute__((__visibility__ ("hidden")));
+// }
+//
+// // copied from https://github.com/gcc-mirror/
+// namespace std
+// {
+//     void __throw_bad_alloc() { _GLIBCXX_THROW_OR_ABORT(bad_alloc()); }
+//     void __throw_length_error(const char* __s __attribute__((unused))) { _GLIBCXX_THROW_OR_ABORT(length_error(_(__s))); }
+//     void __throw_bad_function_call() { _GLIBCXX_THROW_OR_ABORT(bad_function_call()); }
+//     void _Rb_tree_decrement(std::_Rb_tree_node_base* a) {}
+//     void _Rb_tree_insert_and_rebalance(bool, std::_Rb_tree_node_base*, std::_Rb_tree_node_base*, std::_Rb_tree_node_base&) {}
+// }
+
+#endif // TEENSYDUINO_DIRTY_STL_ERROR_SOLUTION
+#endif // TEENSYDUINO
+
diff --git a/examples/custom_class/custom_class.ino b/examples/custom_class/custom_class.ino
new file mode 100644
index 0000000..99a286a
--- /dev/null
+++ b/examples/custom_class/custom_class.ino
@@ -0,0 +1,60 @@
+#include <Tween.h>
+
+struct Vec2
+{
+    float x;
+    float y;
+
+    Vec2() : x(0), y(0) {}
+    Vec2(const float x, const float y) : x(x), y(y) {}
+
+    Vec2 operator+ (const Vec2& rhs) const
+    {
+        return Vec2(x + rhs.x, y + rhs.y);
+    }
+    Vec2 operator- (const Vec2& rhs) const
+    {
+        return Vec2(x - rhs.x, y - rhs.y);
+    }
+    Vec2 operator* (const float f) const
+    {
+        return Vec2(x * f, y * f);
+    }
+
+    // CAUTION: just a simplified operator overloads
+};
+
+
+Tween::Timeline timeline;
+Vec2 v;
+
+void setup()
+{
+    Serial.begin(115200);
+    delay(2000);
+
+    timeline.add(v, Vec2(10, 8), 5000)
+        .then(Vec2(5, 10), 5000)
+        .wait(3000)
+        .then<Ease::Bounce>(Vec2(0, 0), 7000);
+
+    Serial.println("vx, vy"); // serial plotter label
+
+    timeline.start(); // must be started to tween items in timeline
+}
+
+void loop()
+{
+    timeline.update(); // must be called to update tween in timeline
+
+    if (timeline.sec() <= 20)
+    {
+        static uint32_t prev_ms = millis();
+        if (millis() > prev_ms + 50)
+        {
+            Serial.print(v.x); Serial.print(", ");
+            Serial.print(v.y); Serial.println();
+            prev_ms = millis();
+        }
+    }
+}
diff --git a/examples/fastled/fastled.ino b/examples/fastled/fastled.ino
new file mode 100644
index 0000000..dc37f83
--- /dev/null
+++ b/examples/fastled/fastled.ino
@@ -0,0 +1,47 @@
+#include <Tween.h>
+#include <FastLED.h>
+
+Tween::Timeline timeline;
+CRGB c;
+
+void setup()
+{
+    Serial.begin(115200);
+    delay(2000);
+
+    timeline.add<Ease::Sine>(c, CRGB(64, 32, 128), 5000)
+        .then<Ease::Expo>(CRGB(255, 255, 255), 5000)
+        .wait(3000)
+        .then<Ease::Bounce>(CRGB(0, 0, 0), 7000);
+
+    Serial.println("r, g, b"); // serial plotter label
+
+    FastLED.addLeds<NEOPIXEL, 13>(&c, 1);
+
+    timeline.start(); // must be started to tween items in timeline
+}
+
+void loop()
+{
+    timeline.update(); // must be called to update tween in timeline
+
+    if (timeline.sec() <= 20)
+    {
+        static uint32_t prev_ms = millis();
+        if (millis() > prev_ms + 20)
+        {
+            Serial.print(c.r); Serial.print(", ");
+            Serial.print(c.g); Serial.print(", ");
+            Serial.print(c.b); Serial.println();
+
+            FastLED.show();
+
+            prev_ms = millis();
+        }
+    }
+    else
+    {
+        c = CRGB::Black;
+        FastLED.show();
+    }
+}
diff --git a/examples/simple/simple.ino b/examples/simple/simple.ino
new file mode 100644
index 0000000..508edd6
--- /dev/null
+++ b/examples/simple/simple.ino
@@ -0,0 +1,45 @@
+#include <Tween.h>
+
+Tween::Timeline timeline;
+
+float a = 0;
+float b = 0.f;
+
+void setup()
+{
+    Serial.begin(115200);
+    delay(2000);
+
+    // tween target value a to 10 in 5000[ms]
+    timeline.add(a, 10, 5000)
+        .then(5, 5000)  // and then Ease::Linear to 5 in 5000[ms]
+        .wait(3000)     // and stop 1000[ms]
+        .then(0, 7000); // and then Ease::Linear to 0 in 4000[ms]
+
+    // Ease::Sine target value b to 10 in 5000[ms]
+    timeline.add<Ease::Sine>(b, 10, 5000)
+        .then<Ease::Elastic>(5, 5000) // and then Ease::Elastic to 5 in 5000[ms]
+        .wait(3000)                   // and stop 1000[ms]
+        .then<Ease::Bounce>(0, 7000); // and then Ease::Bounce to 0 in 4000[ms]
+
+    Serial.println("a, b"); // serial plotter label
+
+    timeline.start(); // must be started to tween items in timeline
+}
+
+void loop()
+{
+    timeline.update(); // must be called to update tween in timeline
+
+    // show plot if timeline runs in 10sec
+    if (timeline.sec() <= 20)
+    {
+        static uint32_t prev_ms = millis();
+        if (millis() > prev_ms + 50)
+        {
+            Serial.print(a); Serial.print(", ");
+            Serial.print(b); Serial.println();
+            prev_ms = millis();
+        }
+    }
+}