diff --git a/include/tween.h b/include/tween.h
index ad64dfd..1e5bf46 100644
--- a/include/tween.h
+++ b/include/tween.h
@@ -250,7 +250,8 @@ namespace tweeny {
              * @param suppressCallbacks (Optional) Suppress callbacks registered with tween::onStep()
              * @returns std::tuple<Ts...> with the current tween values.
              */
-            const typename detail::tweentraits<T, Ts...>::valuesType & step(float dp, bool suppressCallbacks = false);
+            const typename detail::tweentraits<T, Ts...>::valuesType &step(
+                float dp, bool suppressCallbacks = false);
 
             /**
              * @brief Seeks to a specified point in time based on the currentProgress.
@@ -261,7 +262,8 @@ namespace tweeny {
              * @param suppressCallbacks (Optional) Suppress callbacks registered with tween::onSeek()
              * @returns std::tuple<Ts...> with the current tween values.
              */
-            const typename detail::tweentraits<T, Ts...>::valuesType & seek(float p, bool suppressCallbacks = false);
+            const typename detail::tweentraits<T, Ts...>::valuesType &seek(
+                float p, bool suppressCallbacks = false);
 
             /**
              * @brief Seeks to a specified point in time.
@@ -285,7 +287,8 @@ namespace tweeny {
              * @returns std::tuple<Ts...> with the current tween values.
              * @see duration
              */
-            const typename detail::tweentraits<T, Ts...>::valuesType & seek(uint32_t d, bool suppressCallbacks = false);
+            const typename detail::tweentraits<T, Ts...>::valuesType &seek(
+                uint32_t d, bool suppressCallbacks = false);
 
             /**
              * @brief Adds a callback that will be called when stepping occurs, accepting both the tween and
@@ -506,6 +509,13 @@ namespace tweeny {
              */
             const typename detail::tweentraits<T, Ts...>::valuesType peek(uint32_t time) const;
 
+            /**
+             * @brief Returns the current time point of the interpolation.
+             *
+             * @returns the current timr point between 0 and total time point (inclusive)
+             */
+            uint32_t currentTimePoint() const; ///< @sa tween::currenttimepoint
+
             /**
              * @brief Returns the current currentProgress of the interpolation.
              *
@@ -514,6 +524,13 @@ namespace tweeny {
              */
             float progress() const;
 
+            /**
+             * @brief Returns true if tween reach to end of interpolation progress.
+             *
+             * @returns True means its finished, false means its in progress.
+             */
+            bool isFinished() const;
+
             /**
              * @brief Sets the direction of this tween forward.
              *
@@ -564,7 +581,7 @@ namespace tweeny {
         private /* member variables */:
             uint32_t total = 0; // total runtime
             uint16_t currentPoint = 0; // current point
-            float currentProgress = 0; // current progress
+            uint32_t currentProgress = 0; // current progress
             std::vector<detail::tweenpoint<T, Ts...>> points;
             typename traits::valuesType current;
             std::vector<typename traits::callbackType> onStepCallbacks;
@@ -574,11 +591,18 @@ namespace tweeny {
         private:
             /* member functions */
             tween(T t, Ts... vs);
-            template<size_t I> void interpolate(float prog, unsigned point, typename traits::valuesType & values, detail::int2type<I>) const;
-            void interpolate(float prog, unsigned point, typename traits::valuesType & values, detail::int2type<0>) const;
-            void render(float p);
+            template<size_t I>
+            void interpolate(uint32_t prog,
+                             unsigned point,
+                             typename traits::valuesType &values,
+                             detail::int2type<I>) const;
+            void interpolate(uint32_t prog,
+                             unsigned point,
+                             typename traits::valuesType &values,
+                             detail::int2type<0>) const;
+            void render(uint32_t p);
             void dispatch(std::vector<typename traits::callbackType> & cbVector);
-            uint16_t pointAt(float progress) const;
+            uint16_t pointAt(uint32_t progress) const;
     };
 
     /**
@@ -607,8 +631,12 @@ namespace tweeny {
             template<typename... Ds> tween<T> & during(Ds... ds); ///< @sa tween::during
             const T & step(int32_t dt, bool suppressCallbacks = false); ///< @sa tween::step(int32_t dt, bool suppressCallbacks)
             const T & step(uint32_t dt, bool suppressCallbacks = false); ///< @sa tween::step(uint32_t dt, bool suppressCallbacks)
-            const T & step(float dp, bool suppressCallbacks = false); ///< @sa tween::step(float dp, bool suppressCallbacks)
-            const T & seek(float p, bool suppressCallbacks = false); ///< @sa tween::seek(float p, bool suppressCallbacks)
+            const T &step(float dp,
+                          bool suppressCallbacks
+                          = false); ///< @sa tween::step(float dp, bool suppressCallbacks)
+            const T &seek(float p,
+                          bool suppressCallbacks
+                          = false); ///< @sa tween::seek(float p, bool suppressCallbacks)
             const T & seek(int32_t d, bool suppressCallbacks = false); ///< @sa tween::seek(int32_t d, bool suppressCallbacks)
             const T & seek(uint32_t d, bool suppressCallbacks = false); ///< @sa tween::seek(uint32_t d, bool suppressCallbacks)
             tween<T> & onStep(typename detail::tweentraits<T>::callbackType callback); ///< @sa tween::onStep
@@ -621,7 +649,9 @@ namespace tweeny {
             T peek(float progress) const; ///< @sa tween::peek
             T peek(uint32_t time) const; ///< @sa tween::peek
             uint32_t duration() const; ///< @sa tween::duration
-            float progress() const; ///< @sa tween::progress
+            uint32_t currentTimePoint() const; ///< @sa tween::currenttimepoint
+            float progress() const;            ///< @sa tween::progress
+            bool isFinished() const;           ///< @sa tween::isFinished
             tween<T> & forward(); ///< @sa tween::forward
             tween<T> & backward(); ///< @sa tween::backward
             int direction() const; ///< @sa tween::direction
@@ -634,7 +664,7 @@ namespace tweeny {
         private /* member variables */:
             uint32_t total = 0; // total runtime
             uint16_t currentPoint = 0; // current point
-            float currentProgress = 0; // current progress
+            uint32_t currentProgress = 0; // current progress
             std::vector<detail::tweenpoint<T>> points;
             T current;
             std::vector<typename traits::callbackType> onStepCallbacks;
@@ -644,10 +674,10 @@ namespace tweeny {
         private:
             /* member functions */
             tween(T t);
-            void interpolate(float prog, unsigned point, T & value) const;
-            void render(float p);
+            void interpolate(uint32_t prog, unsigned point, T &value) const;
+            void render(uint32_t p);
             void dispatch(std::vector<typename traits::callbackType> & cbVector);
-            uint16_t pointAt(float progress) const;
+            uint16_t pointAt(uint32_t progress) const;
     };
 }
 
diff --git a/include/tween.tcc b/include/tween.tcc
index dd0e77f..ae19008 100644
--- a/include/tween.tcc
+++ b/include/tween.tcc
@@ -29,8 +29,9 @@
 #ifndef TWEENY_TWEEN_TCC
 #define TWEENY_TWEEN_TCC
 
-#include "tween.h"
 #include "dispatcher.h"
+#include "tween.h"
+#include <cstdlib>
 
 namespace tweeny {
 
@@ -165,7 +166,11 @@ namespace tweeny {
 
     template<typename T, typename... Ts>
     inline const typename detail::tweentraits<T, Ts...>::valuesType & tween<T, Ts...>::step(int32_t dt, bool suppress) {
-        return step(static_cast<float>(dt)/static_cast<float>(total), suppress);
+        dt *= currentDirection;
+        seek(currentProgress + dt, true);
+        if (!suppress)
+            dispatch(onStepCallbacks);
+        return current;
     }
 
     template<typename T, typename... Ts>
@@ -174,25 +179,34 @@ namespace tweeny {
     }
 
     template<typename T, typename... Ts>
-    inline const typename detail::tweentraits<T, Ts...>::valuesType & tween<T, Ts...>::step(float dp, bool suppress) {
-        dp *= currentDirection;
-        seek(currentProgress + dp, true);
-        if (!suppress) dispatch(onStepCallbacks);
-        return current;
+    inline const typename detail::tweentraits<T, Ts...>::valuesType &tween<T, Ts...>::step(
+        float dp, bool suppress)
+    {
+        return step(static_cast<int32_t>(dp * total), suppress);
     }
 
     template<typename T, typename... Ts>
-    inline const typename detail::tweentraits<T, Ts...>::valuesType & tween<T, Ts...>::seek(float p, bool suppress) {
-        p = detail::clip(p, 0.0f, 1.0f);
+    inline const typename detail::tweentraits<T, Ts...>::valuesType &tween<T, Ts...>::seek(
+        uint32_t p, bool suppress)
+    {
+        p = detail::clip(p, 0u, total);
         currentProgress = p;
         render(p);
-        if (!suppress) dispatch(onSeekCallbacks);
+        if (!suppress)
+            dispatch(onSeekCallbacks);
         return current;
     }
 
     template<typename T, typename... Ts>
     inline const typename detail::tweentraits<T, Ts...>::valuesType & tween<T, Ts...>::seek(int32_t t, bool suppress) {
-        return seek(static_cast<float>(t) / static_cast<float>(total), suppress);
+        return seek(static_cast<uint32_t>(std::abs(t)), suppress);
+    }
+
+	template<typename T, typename... Ts>
+	inline const typename detail::tweentraits<T, Ts...>::valuesType &tween<T, Ts...>::seek(
+		float p, bool suppress)
+	{
+        return seek(static_cast<int32_t>(p * total), suppress);
     }
 
     template<typename T, typename... Ts>
@@ -202,9 +216,13 @@ namespace tweeny {
 
     template<typename T, typename... Ts>
     template<size_t I>
-    inline void tween<T, Ts...>::interpolate(float prog, unsigned point, typename traits::valuesType & values, detail::int2type<I>) const {
+    inline void tween<T, Ts...>::interpolate(uint32_t prog,
+                                             unsigned point,
+                                             typename traits::valuesType &values,
+                                             detail::int2type<I>) const
+    {
         auto & p = points.at(point);
-        auto pointDuration = uint32_t(p.duration() - (p.stacked - (prog * static_cast<float>(total))));
+        auto pointDuration = uint32_t(p.duration() - (p.stacked - prog));
         float pointTotal = static_cast<float>(pointDuration) / static_cast<float>(p.duration(I));
         if (pointTotal > 1.0f) pointTotal = 1.0f;
         auto easing = std::get<I>(p.easings);
@@ -213,9 +231,13 @@ namespace tweeny {
     }
 
     template<typename T, typename... Ts>
-    inline void tween<T, Ts...>::interpolate(float prog, unsigned point, typename traits::valuesType & values, detail::int2type<0>) const {
+    inline void tween<T, Ts...>::interpolate(uint32_t prog,
+                                             unsigned point,
+                                             typename traits::valuesType &values,
+                                             detail::int2type<0>) const
+    {
         auto & p = points.at(point);
-        auto pointDuration = uint32_t(p.duration() - (p.stacked - (prog * static_cast<float>(total))));
+        auto pointDuration = uint32_t(p.duration() - (p.stacked - prog));
         float pointTotal = static_cast<float>(pointDuration) / static_cast<float>(p.duration(0));
         if (pointTotal > 1.0f) pointTotal = 1.0f;
         auto easing = std::get<0>(p.easings);
@@ -223,7 +245,8 @@ namespace tweeny {
     }
 
     template<typename T, typename... Ts>
-    inline void tween<T, Ts...>::render(float p) {
+    inline void tween<T, Ts...>::render(uint32_t p)
+    {
         currentPoint = pointAt(p);
         interpolate(p, currentPoint, current, detail::int2type<sizeof...(Ts) - 1 + 1 /* +1 for the T */>{ });
     }
@@ -290,23 +313,42 @@ namespace tweeny {
     template<typename T, typename... Ts>
     const typename detail::tweentraits<T, Ts...>::valuesType tween<T, Ts...>::peek(float progress) const {
         typename detail::tweentraits<T, Ts...>::valuesType values;
-        interpolate(progress, pointAt(progress), values, detail::int2type<sizeof...(Ts) - 1 + 1 /* +1 for the T */>{ });
+        uint32_t time = progress * total;
+        interpolate(time,
+                    pointAt(time),
+                    values,
+                    detail::int2type<sizeof...(Ts) - 1 + 1 /* +1 for the T */>{});
         return values;
     }
 
     template<typename T, typename... Ts>
     const typename detail::tweentraits<T, Ts...>::valuesType tween<T, Ts...>::peek(uint32_t time) const {
         typename detail::tweentraits<T, Ts...>::valuesType values;
-        float progress = static_cast<float>(time) / static_cast<float>(total);
-        interpolate(progress, pointAt(progress), values, detail::int2type<sizeof...(Ts) - 1 + 1 /* +1 for the T */>{ });
+        interpolate(time,
+                    pointAt(time),
+                    values,
+                    detail::int2type<sizeof...(Ts) - 1 + 1 /* +1 for the T */>{});
         return values;
     }
 
-  template<typename T, typename... Ts>
-    float tween<T, Ts...>::progress() const {
+    template<typename T, typename... Ts>
+    uint32_t tween<T, Ts...>::currentTimePoint() const
+    {
         return currentProgress;
     }
 
+    template<typename T, typename... Ts>
+    float tween<T, Ts...>::progress() const
+    {
+        return static_cast<float>(currentProgress) / static_cast<float>(total);
+    }
+
+    template<typename T, typename... Ts>
+    bool tween<T, Ts...>::isFinished() const
+    {
+        return currentProgress == total;
+    }
+
     template<typename T, typename... Ts>
     tween<T, Ts...> & tween<T, Ts...>::forward() {
         currentDirection = 1;
@@ -334,12 +376,15 @@ namespace tweeny {
         return currentPoint;
     }
 
-    template<typename T, typename... Ts> inline uint16_t tween<T, Ts...>::pointAt(float progress) const {
-        progress = detail::clip(progress, 0.0f, 1.0f);
-        uint32_t t = static_cast<uint32_t>(progress * total);
+    template<typename T, typename... Ts>
+    inline uint16_t tween<T, Ts...>::pointAt(uint32_t progress) const
+    {
+        progress = detail::clip(progress, 0u, total);
         uint16_t point = 0;
-        while (t > points.at(point).stacked) point++;
-        if (point > 0 && t <= points.at(point - 1u).stacked) point--;
+        while (progress > points.at(point).stacked)
+            point++;
+        if (point > 0 && progress <= points.at(point - 1u).stacked)
+            point--;
         return point;
     }
 }
diff --git a/include/tweenone.tcc b/include/tweenone.tcc
index c2a52ad..ec07c69 100644
--- a/include/tweenone.tcc
+++ b/include/tweenone.tcc
@@ -157,7 +157,11 @@ namespace tweeny {
 
     template<typename T>
     inline const T & tween<T>::step(int32_t dt, bool suppress) {
-        return step(static_cast<float>(dt)/static_cast<float>(total), suppress);
+        dt *= currentDirection;
+        seek(currentProgress + dt, true);
+        if (!suppress)
+            dispatch(onStepCallbacks);
+        return current;
     }
 
     template<typename T>
@@ -166,30 +170,30 @@ namespace tweeny {
     }
 
     template<typename T>
-    inline const T & tween<T>::step(float dp, bool suppress) {
-        dp *= currentDirection;
-        seek(currentProgress + dp, true);
-        if (!suppress) dispatch(onStepCallbacks);
-        return current;
+    inline const T &tween<T>::step(float dp, bool suppress)
+    {
+        return step(static_cast<int32_t>(dp * total), suppress);
     }
 
     template<typename T>
-    inline const T & tween<T>::seek(float p, bool suppress) {
-        p = detail::clip(p, 0.0f, 1.0f);
-        currentProgress = p;
-        render(p);
-        if (!suppress) dispatch(onSeekCallbacks);
-        return current;
+    inline const T &tween<T>::seek(float p, bool suppress)
+    {
+        return seek(static_cast<int32_t>(p * total), suppress);
     }
 
     template<typename T>
     inline const T & tween<T>::seek(int32_t t, bool suppress) {
-        return seek(static_cast<float>(t) / static_cast<float>(total), suppress);
+        t = detail::clip(t, 0, (int32_t) total);
+        currentProgress = t;
+        render(t);
+        if (!suppress)
+            dispatch(onSeekCallbacks);
+        return current;
     }
 
     template<typename T>
     inline const T & tween<T>::seek(uint32_t t, bool suppress) {
-        return seek(static_cast<float>(t) / static_cast<float>(total), suppress);
+        return seek(static_cast<int32_t>(t), suppress);
     }
 
     template<typename T>
@@ -198,9 +202,10 @@ namespace tweeny {
     }
 
     template<typename T>
-    inline void tween<T>::interpolate(float prog, unsigned point, T & value) const {
+    inline void tween<T>::interpolate(uint32_t prog, unsigned point, T &value) const
+    {
         auto & p = points.at(point);
-        auto pointDuration = uint32_t(p.duration() - (p.stacked - (prog * static_cast<float>(total))));
+        auto pointDuration = uint32_t(p.duration() - (p.stacked - prog));
         float pointTotal = static_cast<float>(pointDuration) / static_cast<float>(p.duration());
         if (pointTotal > 1.0f) pointTotal = 1.0f;
         auto easing = std::get<0>(p.easings);
@@ -208,7 +213,8 @@ namespace tweeny {
     }
 
     template<typename T>
-    inline void tween<T>::render(float p) {
+    inline void tween<T>::render(uint32_t p)
+    {
         currentPoint = pointAt(p);
         interpolate(p, currentPoint, current);
     }
@@ -276,26 +282,38 @@ namespace tweeny {
     template<typename T>
     T tween<T>::peek(float progress) const {
         T value;
-        interpolate(progress, pointAt(progress), value);
+        interpolate(progress * total, pointAt(progress * total), value);
         return value;
     }
 
     template<typename T>
     T tween<T>::peek(uint32_t time) const {
         T value;
-        float progress = static_cast<float>(time) / static_cast<float>(total);
-        interpolate(progress, pointAt(progress), value);
+        interpolate(time, pointAt(time), value);
         return value;
     }
 
-
-  template<typename T>
-    float tween<T>::progress() const {
+    template<typename T>
+    uint32_t tween<T>::currentTimePoint() const
+    {
         return currentProgress;
     }
 
     template<typename T>
-    tween<T> & tween<T>::forward() {
+    float tween<T>::progress() const
+    {
+        return static_cast<float>(currentProgress) / static_cast<float>(total);
+    }
+
+    template<typename T>
+    bool tween<T>::isFinished() const
+    {
+        return currentProgress == total;
+    }
+
+    template<typename T>
+    tween<T> &tween<T>::forward()
+    {
         currentDirection = 1;
         return *this;
     }
@@ -321,11 +339,11 @@ namespace tweeny {
         return currentPoint;
     }
 
-
-
-    template<typename T> inline uint16_t tween<T>::pointAt(float progress) const {
-        progress = detail::clip(progress, 0.0f, 1.0f);
-        auto t = static_cast<uint32_t>(progress * total);
+    template<typename T>
+    inline uint16_t tween<T>::pointAt(uint32_t timePoint) const
+    {
+        timePoint = detail::clip(timePoint, 0u, total);
+        auto t = static_cast<uint32_t>(timePoint);
         uint16_t point = 0;
         while (t > points.at(point).stacked) point++;
         if (point > 0 && t <= points.at(point - 1u).stacked) point--;