diff --git a/Kernel/include_std/chrono b/Kernel/include_std/chrono
index 05cc14dd..35b21a8e 100644
--- a/Kernel/include_std/chrono
+++ b/Kernel/include_std/chrono
@@ -28,22 +28,25 @@ namespace std
 		class duration
 		{
 		private:
-			Rep rep_;
-			std::ratio<Period::num, Period::denom> period_;
+			Rep _rep;
+			std::ratio<Period::num, Period::den> _period;
 
 		public:
+			using rep = Rep;
+			using period = Period;
+
 			constexpr duration() = default;
 			duration(const duration &) = default;
 
 			template <class Rep2>
-			constexpr explicit duration(const Rep2 &r) { rep_ = r; }
+			constexpr explicit duration(const Rep2 &r) { _rep = r; }
 
 			template <class Rep2, class Period2>
 			constexpr duration(const duration<Rep2, Period2> &d);
 
 			duration &operator=(const duration &other) = default;
 
-			constexpr Rep count() const { return rep_; }
+			constexpr Rep count() const { return _rep; }
 
 			static constexpr duration zero() noexcept;
 			static constexpr duration min() noexcept;
@@ -51,54 +54,54 @@ namespace std
 			constexpr std::common_type_t<duration> operator+() const;
 			constexpr std::common_type_t<duration> operator-() const;
 
-			constexpr duration operator++(int) { return duration(rep_++); }
-			constexpr duration operator--(int) { return duration(rep_--); }
+			constexpr duration operator++(int) { return duration(_rep++); }
+			constexpr duration operator--(int) { return duration(_rep--); }
 
 			constexpr duration &operator++()
 			{
-				++rep_;
+				++_rep;
 				return *this;
 			}
 
 			constexpr duration &operator--()
 			{
-				--rep_;
+				--_rep;
 				return *this;
 			}
 
 			constexpr duration &operator+=(const duration &d)
 			{
-				rep_ += d.count();
+				_rep += d.count();
 				return *this;
 			}
 
 			constexpr duration &operator-=(const duration &d)
 			{
-				rep_ -= d.count();
+				_rep -= d.count();
 				return *this;
 			}
 
 			constexpr duration &operator*=(const Rep &rhs)
 			{
-				rep_ *= rhs;
+				_rep *= rhs;
 				return *this;
 			}
 
 			constexpr duration &operator/=(const Rep &rhs)
 			{
-				rep_ /= rhs;
+				_rep /= rhs;
 				return *this;
 			}
 
 			constexpr duration &operator%=(const Rep &rhs)
 			{
-				rep_ %= rhs;
+				_rep %= rhs;
 				return *this;
 			}
 
 			constexpr duration &operator%=(const duration &rhs)
 			{
-				rep_ %= rhs.count();
+				_rep %= rhs.count();
 				return *this;
 			}
 		};
@@ -120,7 +123,91 @@ namespace std
 		template <class ToDuration, class Rep, class Period>
 		constexpr ToDuration duration_cast(const std::chrono::duration<Rep, Period> &d)
 		{
-			return ToDuration(d.count());
+			typedef typename ToDuration::rep ToRep;
+			typedef typename ToDuration::period ToPeriod;
+			typedef std::ratio_divide<Period, ToPeriod> CF;
+			typedef typename std::common_type<Rep, ToRep, intmax_t>::type CR;
+			CR cr_count = static_cast<CR>(d.count());
+			CR cr_num = static_cast<CR>(CF::num);
+			CR cr_den = static_cast<CR>(CF::den);
+
+			if constexpr (CF::num == 1 && CF::den == 1)
+				return ToDuration(static_cast<ToRep>(cr_count));
+			else if constexpr (CF::den == 1)
+				return ToDuration(static_cast<ToRep>(cr_count * cr_num));
+			else if constexpr (CF::num == 1)
+				return ToDuration(static_cast<ToRep>(cr_count / cr_den));
+			else
+				return ToDuration(static_cast<ToRep>(cr_count * cr_num / cr_den));
+		}
+	}
+
+	inline namespace literals
+	{
+		inline namespace chrono_literals
+		{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wliteral-suffix"
+			constexpr std::chrono::hours operator""h(unsigned long long h)
+			{
+				return std::chrono::hours(h);
+			}
+
+			constexpr std::chrono::duration<long double, std::ratio<3600, 1>> operator""h(long double h)
+			{
+				return std::chrono::duration<long double, std::ratio<3600, 1>>(h);
+			}
+
+			constexpr std::chrono::minutes operator""min(unsigned long long m)
+			{
+				return std::chrono::minutes(m);
+			}
+
+			constexpr std::chrono::duration<long double, std::ratio<60, 1>> operator""min(long double m)
+			{
+				return std::chrono::duration<long double, std::ratio<60, 1>>(m);
+			}
+
+			constexpr std::chrono::seconds operator""s(unsigned long long s)
+			{
+				return std::chrono::seconds(s);
+			}
+
+			constexpr std::chrono::duration<long double> operator""s(long double s)
+			{
+				return std::chrono::duration<long double>(s);
+			}
+
+			constexpr std::chrono::milliseconds operator""ms(unsigned long long ms)
+			{
+				return std::chrono::milliseconds(ms);
+			}
+
+			constexpr std::chrono::duration<long double, std::milli> operator""ms(long double ms)
+			{
+				return std::chrono::duration<long double, std::milli>(ms);
+			}
+
+			constexpr std::chrono::microseconds operator""us(unsigned long long us)
+			{
+				return std::chrono::microseconds(us);
+			}
+
+			constexpr std::chrono::duration<long double, std::micro> operator""us(long double us)
+			{
+				return std::chrono::duration<long double, std::micro>(us);
+			}
+
+			constexpr std::chrono::nanoseconds operator""ns(unsigned long long ns)
+			{
+				return std::chrono::nanoseconds(ns);
+			}
+
+			constexpr std::chrono::duration<long double, std::nano> operator""ns(long double ns)
+			{
+				return std::chrono::duration<long double, std::nano>(ns);
+			}
+#pragma GCC diagnostic pop
 		}
 	}
 }
diff --git a/Kernel/include_std/ratio b/Kernel/include_std/ratio
index eddc96f2..6c905b33 100644
--- a/Kernel/include_std/ratio
+++ b/Kernel/include_std/ratio
@@ -17,40 +17,173 @@
 
 #pragma once
 
-#include <types.h>
+#include <type_traits>
 
 namespace std
 {
+	namespace detail
+	{
+		template <intmax_t A, intmax_t B>
+		struct GCD
+		{
+			static constexpr intmax_t value = GCD<B, A % B>::value;
+		};
+
+		template <intmax_t A>
+		struct GCD<A, 0>
+		{
+			static constexpr intmax_t value = A;
+		};
+	}
+
 	template <intmax_t Num, intmax_t Denom = 1>
 	class ratio
 	{
+	private:
+		static_assert(Denom != 0, "Denominator cannot be zero");
+		static_assert(Num >= -__INTMAX_MAX__ && Denom >= -__INTMAX_MAX__, "Overflow");
+
+	private:
+		static constexpr intmax_t __first = Num < 0 ? -Num : Num;
+		static constexpr intmax_t __second = Denom < 0 ? -Denom : Denom;
+		static constexpr intmax_t __gcd = detail::GCD<__first, __second>::value;
+
 	public:
 		typedef ratio<Num, Denom> type;
-		static constexpr intmax_t num = Num;
-		static constexpr intmax_t denom = Denom;
+		static constexpr intmax_t num = Denom < 0 ? -Num / __gcd : Num / __gcd;
+		static constexpr intmax_t den = Denom < 0 ? -Denom / __gcd : Denom / __gcd;
+	};
+
+	namespace detail
+	{
+		template <typename _Tp>
+		constexpr bool __ta_is_ratio = false;
+
+		template <intmax_t _Num, intmax_t _Den>
+		constexpr bool __ta_is_ratio<ratio<_Num, _Den>> = true;
+
+		template <class R1, class R2>
+		constexpr bool __is_equal()
+		{
+			return R1::num == R2::num && R1::den == R2::den;
+		}
+
+		template <class R1, class R2>
+		constexpr bool __is_less()
+		{
+			return R1::num * R2::den < R2::num * R1::den;
+		}
+
+		template <class R1, class R2>
+		constexpr bool __is_less_or_equal()
+		{
+			return R1::num * R2::den <= R2::num * R1::den;
+		}
+
+		template <class R1, class R2>
+		constexpr bool __is_greater()
+		{
+			return R1::num * R2::den > R2::num * R1::den;
+		}
+
+		template <class R1, class R2>
+		constexpr bool __is_greater_or_equal()
+		{
+			return R1::num * R2::den >= R2::num * R1::den;
+		}
 	};
 
 	template <class R1, class R2>
-	using ratio_add = ratio<R1::num * R2::denom + R2::num * R1::denom, R1::denom * R2::denom>;
-	template <class R1, class R2>
-	using ratio_subtract = ratio<R1::num * R2::denom - R2::num * R1::denom, R1::denom * R2::denom>;
-	template <class R1, class R2>
-	using ratio_multiply = ratio<R1::num * R2::num, R1::denom * R2::denom>;
-	template <class R1, class R2>
-	using ratio_divide = ratio<R1::num * R2::denom, R1::denom * R2::num>;
+	struct ratio_add
+	{
+		static_assert(detail::__ta_is_ratio<R1> && detail::__ta_is_ratio<R2>, "Both template arguments must be std::ratio");
+
+		static constexpr intmax_t num = R1::num * R2::den + R2::num * R1::den;
+		static constexpr intmax_t den = R1::den * R2::den;
+
+		using type = ratio<num, den>;
+	};
 
 	template <class R1, class R2>
-	struct ratio_equal;
+	struct ratio_subtract
+	{
+		static_assert(detail::__ta_is_ratio<R1> && detail::__ta_is_ratio<R2>, "Both template arguments must be std::ratio");
+
+		static constexpr intmax_t num = R1::num * R2::den - R2::num * R1::den;
+		static constexpr intmax_t den = R1::den * R2::den;
+
+		using type = ratio<num, den>;
+	};
+
 	template <class R1, class R2>
-	struct ratio_not_equal;
+	struct ratio_multiply
+	{
+		static_assert(detail::__ta_is_ratio<R1> && detail::__ta_is_ratio<R2>, "Both templates must be ratios");
+
+		static constexpr intmax_t num = R1::num * R2::num;
+		static constexpr intmax_t den = R1::den * R2::den;
+
+		using type = ratio<num, den>;
+	};
+
 	template <class R1, class R2>
-	struct ratio_less;
+	struct ratio_divide
+	{
+		static_assert(R2::num != 0, "Divide by zero");
+
+		static constexpr intmax_t num = R1::num * R2::den;
+		static constexpr intmax_t den = R1::den * R2::num;
+
+		using type = ratio<num, den>;
+	};
+
 	template <class R1, class R2>
-	struct ratio_less_equal;
+	struct ratio_equal : public std::integral_constant<bool, detail::__is_equal<R1, R2>()>
+	{
+	};
+
 	template <class R1, class R2>
-	struct ratio_greater;
+	struct ratio_not_equal : public std::integral_constant<bool, !detail::__is_equal<R1, R2>()>
+	{
+	};
+
 	template <class R1, class R2>
-	struct ratio_greater_equal;
+	struct ratio_less : public std::integral_constant<bool, detail::__is_less<R1, R2>()>
+	{
+	};
+
+	template <class R1, class R2>
+	struct ratio_less_equal : public std::integral_constant<bool, detail::__is_less_or_equal<R1, R2>()>
+	{
+	};
+
+	template <class R1, class R2>
+	struct ratio_greater : public std::integral_constant<bool, detail::__is_greater<R1, R2>()>
+	{
+	};
+
+	template <class R1, class R2>
+	struct ratio_greater_equal : public std::integral_constant<bool, detail::__is_greater_or_equal<R1, R2>()>
+	{
+	};
+
+	template <class R1, class R2>
+	constexpr bool ratio_equal_v = ratio_equal<R1, R2>::value;
+
+	template <class R1, class R2>
+	constexpr bool ratio_not_equal_v = ratio_not_equal<R1, R2>::value;
+
+	template <class R1, class R2>
+	constexpr bool ratio_less_v = ratio_less<R1, R2>::value;
+
+	template <class R1, class R2>
+	constexpr bool ratio_less_equal_v = ratio_less_equal<R1, R2>::value;
+
+	template <class R1, class R2>
+	constexpr bool ratio_greater_v = ratio_greater<R1, R2>::value;
+
+	template <class R1, class R2>
+	constexpr bool ratio_greater_equal_v = ratio_greater_equal<R1, R2>::value;
 
 	// typedef ratio<1, 1000000000000000000000000000000> quecto;
 	// typedef ratio<1, 1000000000000000000000000000> ronto;
diff --git a/Kernel/include_std/thread b/Kernel/include_std/thread
index 51085018..fe2478d1 100644
--- a/Kernel/include_std/thread
+++ b/Kernel/include_std/thread
@@ -21,6 +21,7 @@
 #include <task.hpp>
 #include <debug.h>
 #include <smp.hpp>
+#include <ostream>
 #include <chrono>
 
 extern Tasking::Task *TaskManager;
@@ -84,17 +85,26 @@ namespace std
 
 	namespace this_thread
 	{
-		thread::id get_id() noexcept;
-
 		void yield() noexcept;
 
-		template <class Clock, class Duration>
-		void sleep_until(const chrono::time_point<Clock, Duration> &abs_time);
+		thread::id get_id() noexcept;
 
 		template <class Rep, class Period>
-		void sleep_for(const chrono::duration<Rep, Period> &rel_time)
+		void sleep_for(const chrono::duration<Rep, Period> &sleep_duration)
 		{
-			TaskManager->Sleep(chrono::duration_cast<std::chrono::milliseconds>(rel_time).count());
+			TaskManager->Sleep(chrono::duration_cast<std::chrono::nanoseconds>(sleep_duration).count());
+		}
+
+		template <class Clock, class Duration>
+		void sleep_until(const std::chrono::time_point<Clock, Duration> &sleep_time)
+		{
+			TaskManager->Sleep(chrono::duration_cast<std::chrono::nanoseconds>(sleep_time - Clock::now()).count());
 		}
 	}
+
+	template <class CharT, class Traits>
+	std::basic_ostream<CharT, Traits> &operator<<(std::basic_ostream<CharT, Traits> &ost, std::thread::id id)
+	{
+		return ost << id;
+	}
 }