diff --git a/include/spdlog/details/format.cc b/include/spdlog/details/format.cc
index 8ef64ab9..070bf614 100644
--- a/include/spdlog/details/format.cc
+++ b/include/spdlog/details/format.cc
@@ -1,5 +1,8 @@
 /*
-Formatting library for C++
+
+Modified version of cppformat formatting library
+
+Orginal license:
 
 Copyright (c) 2012 - 2014, Victor Zverovich
 All rights reserved.
@@ -49,9 +52,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 # undef ERROR
 #endif
 
-using fmt::LongLong;
-using fmt::ULongLong;
-using fmt::internal::Arg;
+using spdlog::details::fmt::LongLong;
+using spdlog::details::fmt::ULongLong;
+using spdlog::details::fmt::internal::Arg;
 
 // Check if exceptions are disabled.
 #if __GNUC__ && !__EXCEPTIONS
@@ -127,7 +130,7 @@ struct IntChecker<true> {
 
 const char RESET_COLOR[] = "\x1b[0m";
 
-typedef void(*FormatFunc)(fmt::Writer &, int, fmt::StringRef);
+typedef void(*FormatFunc)(spdlog::details::fmt::Writer &, int, spdlog::details::fmt::StringRef);
 
 // Portable thread-safe version of strerror.
 // Sets buffer to point to a string describing the error code.
@@ -166,27 +169,27 @@ FMT_FUNC int safe_strerror(
     return result;
 }
 
-FMT_FUNC void format_error_code(fmt::Writer &out, int error_code,
-                                fmt::StringRef message) FMT_NOEXCEPT(true) {
+FMT_FUNC void format_error_code(spdlog::details::fmt::Writer &out, int error_code,
+                                spdlog::details::fmt::StringRef message) FMT_NOEXCEPT(true) {
     // Report error code making sure that the output fits into
     // INLINE_BUFFER_SIZE to avoid dynamic memory allocation and potential
     // bad_alloc.
     out.clear();
     static const char SEP[] = ": ";
     static const char ERROR[] = "error ";
-    fmt::internal::IntTraits<int>::MainType ec_value = error_code;
+    spdlog::details::fmt::internal::IntTraits<int>::MainType ec_value = error_code;
     // Subtract 2 to account for terminating null characters in SEP and ERROR.
     std::size_t error_code_size =
-        sizeof(SEP) + sizeof(ERROR) + fmt::internal::count_digits(ec_value) - 2;
-    if (message.size() <= fmt::internal::INLINE_BUFFER_SIZE - error_code_size)
+        sizeof(SEP) + sizeof(ERROR) + spdlog::details::fmt::internal::count_digits(ec_value) - 2;
+    if (message.size() <= spdlog::details::fmt::internal::INLINE_BUFFER_SIZE - error_code_size)
         out << message << SEP;
     out << ERROR << error_code;
-    assert(out.size() <= fmt::internal::INLINE_BUFFER_SIZE);
+    assert(out.size() <= spdlog::details::fmt::internal::INLINE_BUFFER_SIZE);
 }
 
 FMT_FUNC void report_error(FormatFunc func,
-                           int error_code, fmt::StringRef message) FMT_NOEXCEPT(true) {
-    fmt::MemoryWriter full_message;
+                           int error_code, spdlog::details::fmt::StringRef message) FMT_NOEXCEPT(true) {
+    spdlog::details::fmt::MemoryWriter full_message;
     func(full_message, error_code, message);
     // Use Writer::data instead of Writer::c_str to avoid potential memory
     // allocation.
@@ -195,7 +198,7 @@ FMT_FUNC void report_error(FormatFunc func,
 }
 
 // IsZeroInt::visit(arg) returns true iff arg is a zero integer.
-class IsZeroInt : public fmt::internal::ArgVisitor<IsZeroInt, bool> {
+class IsZeroInt : public spdlog::details::fmt::internal::ArgVisitor<IsZeroInt, bool> {
 public:
     template <typename T>
     bool visit_any_int(T value) {
@@ -219,15 +222,15 @@ FMT_FUNC int parse_nonnegative_int(const Char *&s) {
         value = new_value;
     } while ('0' <= *s && *s <= '9');
     if (value > INT_MAX)
-        FMT_THROW(fmt::FormatError("number is too big"));
+        FMT_THROW(spdlog::details::fmt::FormatError("number is too big"));
     return value;
 }
 
 inline void require_numeric_argument(const Arg &arg, char spec) {
     if (arg.type > Arg::LAST_NUMERIC_TYPE) {
         std::string message =
-            fmt::format("format specifier '{}' requires numeric argument", spec);
-        FMT_THROW(fmt::FormatError(message));
+            spdlog::details::fmt::format("format specifier '{}' requires numeric argument", spec);
+        FMT_THROW(spdlog::details::fmt::FormatError(message));
     }
 }
 
@@ -236,71 +239,71 @@ FMT_FUNC void check_sign(const Char *&s, const Arg &arg) {
     char sign = static_cast<char>(*s);
     require_numeric_argument(arg, sign);
     if (arg.type == Arg::UINT || arg.type == Arg::ULONG_LONG) {
-        FMT_THROW(fmt::FormatError(fmt::format(
-                                       "format specifier '{}' requires signed argument", sign)));
+        FMT_THROW(spdlog::details::fmt::FormatError(spdlog::details::fmt::format(
+                      "format specifier '{}' requires signed argument", sign)));
     }
     ++s;
 }
 
 // Checks if an argument is a valid printf width specifier and sets
 // left alignment if it is negative.
-class WidthHandler : public fmt::internal::ArgVisitor<WidthHandler, unsigned> {
+class WidthHandler : public spdlog::details::fmt::internal::ArgVisitor<WidthHandler, unsigned> {
 private:
-    fmt::FormatSpec &spec_;
+    spdlog::details::fmt::FormatSpec &spec_;
 
 public:
-    explicit WidthHandler(fmt::FormatSpec &spec) : spec_(spec) {}
+    explicit WidthHandler(spdlog::details::fmt::FormatSpec &spec) : spec_(spec) {}
 
     unsigned visit_unhandled_arg() {
-        FMT_THROW(fmt::FormatError("width is not integer"));
+        FMT_THROW(spdlog::details::fmt::FormatError("width is not integer"));
         return 0;
     }
 
     template <typename T>
     unsigned visit_any_int(T value) {
-        typedef typename fmt::internal::IntTraits<T>::MainType UnsignedType;
+        typedef typename spdlog::details::fmt::internal::IntTraits<T>::MainType UnsignedType;
         UnsignedType width = value;
-        if (fmt::internal::is_negative(value)) {
-            spec_.align_ = fmt::ALIGN_LEFT;
+        if (spdlog::details::fmt::internal::is_negative(value)) {
+            spec_.align_ = spdlog::details::fmt::ALIGN_LEFT;
             width = 0 - width;
         }
         if (width > INT_MAX)
-            FMT_THROW(fmt::FormatError("number is too big"));
+            FMT_THROW(spdlog::details::fmt::FormatError("number is too big"));
         return static_cast<unsigned>(width);
     }
 };
 
 class PrecisionHandler :
-    public fmt::internal::ArgVisitor<PrecisionHandler, int> {
+    public spdlog::details::fmt::internal::ArgVisitor<PrecisionHandler, int> {
 public:
     unsigned visit_unhandled_arg() {
-        FMT_THROW(fmt::FormatError("precision is not integer"));
+        FMT_THROW(spdlog::details::fmt::FormatError("precision is not integer"));
         return 0;
     }
 
     template <typename T>
     int visit_any_int(T value) {
         if (!IntChecker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
-            FMT_THROW(fmt::FormatError("number is too big"));
+            FMT_THROW(spdlog::details::fmt::FormatError("number is too big"));
         return static_cast<int>(value);
     }
 };
 
 // Converts an integer argument to an integral type T for printf.
 template <typename T>
-class ArgConverter : public fmt::internal::ArgVisitor<ArgConverter<T>, void> {
+class ArgConverter : public spdlog::details::fmt::internal::ArgVisitor<ArgConverter<T>, void> {
 private:
-    fmt::internal::Arg &arg_;
+    spdlog::details::fmt::internal::Arg &arg_;
     wchar_t type_;
 
 public:
-    ArgConverter(fmt::internal::Arg &arg, wchar_t type)
+    ArgConverter(spdlog::details::fmt::internal::Arg &arg, wchar_t type)
         : arg_(arg), type_(type) {}
 
     template <typename U>
     void visit_any_int(U value) {
         bool is_signed = type_ == 'd' || type_ == 'i';
-        using fmt::internal::Arg;
+        using spdlog::details::fmt::internal::Arg;
         if (sizeof(T) <= sizeof(int)) {
             // Extra casts are used to silence warnings.
             if (is_signed) {
@@ -310,31 +313,31 @@ public:
             else {
                 arg_.type = Arg::UINT;
                 arg_.uint_value = static_cast<unsigned>(
-                                      static_cast<typename fmt::internal::MakeUnsigned<T>::Type>(value));
+                                      static_cast<typename spdlog::details::fmt::internal::MakeUnsigned<T>::Type>(value));
             }
         }
         else {
             if (is_signed) {
                 arg_.type = Arg::LONG_LONG;
                 arg_.long_long_value =
-                    static_cast<typename fmt::internal::MakeUnsigned<U>::Type>(value);
+                    static_cast<typename spdlog::details::fmt::internal::MakeUnsigned<U>::Type>(value);
             }
             else {
                 arg_.type = Arg::ULONG_LONG;
                 arg_.ulong_long_value =
-                    static_cast<typename fmt::internal::MakeUnsigned<U>::Type>(value);
+                    static_cast<typename spdlog::details::fmt::internal::MakeUnsigned<U>::Type>(value);
             }
         }
     }
 };
 
 // Converts an integer argument to char for printf.
-class CharConverter : public fmt::internal::ArgVisitor<CharConverter, void> {
+class CharConverter : public spdlog::details::fmt::internal::ArgVisitor<CharConverter, void> {
 private:
-    fmt::internal::Arg &arg_;
+    spdlog::details::fmt::internal::Arg &arg_;
 
 public:
-    explicit CharConverter(fmt::internal::Arg &arg) : arg_(arg) {}
+    explicit CharConverter(spdlog::details::fmt::internal::Arg &arg) : arg_(arg) {}
 
     template <typename T>
     void visit_any_int(T value) {
@@ -362,7 +365,7 @@ inline Arg::StringValue<wchar_t> ignore_incompatible_str(
 }
 }  // namespace
 
-FMT_FUNC void fmt::SystemError::init(
+FMT_FUNC void spdlog::details::fmt::SystemError::init(
     int error_code, StringRef format_str, ArgList args) {
     error_code_ = error_code;
     MemoryWriter w;
@@ -372,7 +375,7 @@ FMT_FUNC void fmt::SystemError::init(
 }
 
 template <typename T>
-FMT_FUNC int fmt::internal::CharTraits<char>::format_float(
+FMT_FUNC int spdlog::details::fmt::internal::CharTraits<char>::format_float(
     char *buffer, std::size_t size, const char *format,
     unsigned width, int precision, T value) {
     if (width == 0) {
@@ -386,7 +389,7 @@ FMT_FUNC int fmt::internal::CharTraits<char>::format_float(
 }
 
 template <typename T>
-FMT_FUNC int fmt::internal::CharTraits<wchar_t>::format_float(
+FMT_FUNC int spdlog::details::fmt::internal::CharTraits<wchar_t>::format_float(
     wchar_t *buffer, std::size_t size, const wchar_t *format,
     unsigned width, int precision, T value) {
     if (width == 0) {
@@ -400,7 +403,7 @@ FMT_FUNC int fmt::internal::CharTraits<wchar_t>::format_float(
 }
 
 template <typename T>
-const char fmt::internal::BasicData<T>::DIGITS[] =
+const char spdlog::details::fmt::internal::BasicData<T>::DIGITS[] =
     "0001020304050607080910111213141516171819"
     "2021222324252627282930313233343536373839"
     "4041424344454647484950515253545556575859"
@@ -419,12 +422,12 @@ const char fmt::internal::BasicData<T>::DIGITS[] =
   factor * 1000000000
 
 template <typename T>
-const uint32_t fmt::internal::BasicData<T>::POWERS_OF_10_32[] = {
+const uint32_t spdlog::details::fmt::internal::BasicData<T>::POWERS_OF_10_32[] = {
     0, FMT_POWERS_OF_10(1)
 };
 
 template <typename T>
-const uint64_t fmt::internal::BasicData<T>::POWERS_OF_10_64[] = {
+const uint64_t spdlog::details::fmt::internal::BasicData<T>::POWERS_OF_10_64[] = {
     0,
     FMT_POWERS_OF_10(1),
     FMT_POWERS_OF_10(ULongLong(1000000000)),
@@ -433,19 +436,19 @@ const uint64_t fmt::internal::BasicData<T>::POWERS_OF_10_64[] = {
     ULongLong(1000000000) * ULongLong(1000000000) * 10
 };
 
-FMT_FUNC void fmt::internal::report_unknown_type(char code, const char *type) {
+FMT_FUNC void spdlog::details::fmt::internal::report_unknown_type(char code, const char *type) {
     if (std::isprint(static_cast<unsigned char>(code))) {
-        FMT_THROW(fmt::FormatError(
-                      fmt::format("unknown format code '{}' for {}", code, type)));
+        FMT_THROW(spdlog::details::fmt::FormatError(
+                      spdlog::details::fmt::format("unknown format code '{}' for {}", code, type)));
     }
-    FMT_THROW(fmt::FormatError(
-                  fmt::format("unknown format code '\\x{:02x}' for {}",
-                              static_cast<unsigned>(code), type)));
+    FMT_THROW(spdlog::details::fmt::FormatError(
+                  spdlog::details::fmt::format("unknown format code '\\x{:02x}' for {}",
+                          static_cast<unsigned>(code), type)));
 }
 
 #ifdef _WIN32
 
-FMT_FUNC fmt::internal::UTF8ToUTF16::UTF8ToUTF16(fmt::StringRef s) {
+FMT_FUNC spdlog::details::fmt::internal::UTF8ToUTF16::UTF8ToUTF16(spdlog::details::fmt::StringRef s) {
     int length = MultiByteToWideChar(
                      CP_UTF8, MB_ERR_INVALID_CHARS, s.c_str(), -1, 0, 0);
     static const char ERROR[] = "cannot convert string from UTF-8 to UTF-16";
@@ -458,14 +461,14 @@ FMT_FUNC fmt::internal::UTF8ToUTF16::UTF8ToUTF16(fmt::StringRef s) {
         FMT_THROW(WindowsError(GetLastError(), ERROR));
 }
 
-FMT_FUNC fmt::internal::UTF16ToUTF8::UTF16ToUTF8(fmt::WStringRef s) {
+FMT_FUNC spdlog::details::fmt::internal::UTF16ToUTF8::UTF16ToUTF8(spdlog::details::fmt::WStringRef s) {
     if (int error_code = convert(s)) {
         FMT_THROW(WindowsError(error_code,
                                "cannot convert string from UTF-16 to UTF-8"));
     }
 }
 
-FMT_FUNC int fmt::internal::UTF16ToUTF8::convert(fmt::WStringRef s) {
+FMT_FUNC int spdlog::details::fmt::internal::UTF16ToUTF8::convert(spdlog::details::fmt::WStringRef s) {
     int length = WideCharToMultiByte(CP_UTF8, 0, s.c_str(), -1, 0, 0, 0, 0);
     if (length == 0)
         return GetLastError();
@@ -477,7 +480,7 @@ FMT_FUNC int fmt::internal::UTF16ToUTF8::convert(fmt::WStringRef s) {
     return 0;
 }
 
-FMT_FUNC void fmt::WindowsError::init(
+FMT_FUNC void spdlog::details::fmt::WindowsError::init(
     int error_code, StringRef format_str, ArgList args) {
     error_code_ = error_code;
     MemoryWriter w;
@@ -488,9 +491,9 @@ FMT_FUNC void fmt::WindowsError::init(
 
 #endif
 
-FMT_FUNC void fmt::internal::format_system_error(
-    fmt::Writer &out, int error_code,
-    fmt::StringRef message) FMT_NOEXCEPT(true) {
+FMT_FUNC void spdlog::details::fmt::internal::format_system_error(
+    spdlog::details::fmt::Writer &out, int error_code,
+    spdlog::details::fmt::StringRef message) FMT_NOEXCEPT(true) {
     FMT_TRY {
         MemoryBuffer<char, INLINE_BUFFER_SIZE> buffer;
         buffer.resize(INLINE_BUFFER_SIZE);
@@ -510,9 +513,9 @@ FMT_FUNC void fmt::internal::format_system_error(
 }
 
 #ifdef _WIN32
-FMT_FUNC void fmt::internal::format_windows_error(
-    fmt::Writer &out, int error_code,
-    fmt::StringRef message) FMT_NOEXCEPT(true) {
+FMT_FUNC void spdlog::details::fmt::internal::format_windows_error(
+    spdlog::details::fmt::Writer &out, int error_code,
+    spdlog::details::fmt::StringRef message) FMT_NOEXCEPT(true) {
     class String {
     private:
         LPWSTR str_;
@@ -548,17 +551,17 @@ FMT_FUNC void fmt::internal::format_windows_error(
 
 // An argument formatter.
 template <typename Char>
-class fmt::internal::ArgFormatter :
-    public fmt::internal::ArgVisitor<fmt::internal::ArgFormatter<Char>, void> {
+class spdlog::details::fmt::internal::ArgFormatter :
+    public spdlog::details::fmt::internal::ArgVisitor<spdlog::details::fmt::internal::ArgFormatter<Char>, void> {
 private:
-    fmt::BasicFormatter<Char> &formatter_;
-    fmt::BasicWriter<Char> &writer_;
-    fmt::FormatSpec &spec_;
+    spdlog::details::fmt::BasicFormatter<Char> &formatter_;
+    spdlog::details::fmt::BasicWriter<Char> &writer_;
+    spdlog::details::fmt::FormatSpec &spec_;
     const Char *format_;
 
 public:
     ArgFormatter(
-        fmt::BasicFormatter<Char> &f, fmt::FormatSpec &s, const Char *fmt)
+        spdlog::details::fmt::BasicFormatter<Char> &f, spdlog::details::fmt::FormatSpec &s, const Char *fmt)
         : formatter_(f), writer_(f.writer()), spec_(s), format_(fmt) {}
 
     template <typename T>
@@ -579,16 +582,16 @@ public:
         }
         if (spec_.align_ == ALIGN_NUMERIC || spec_.flags_ != 0)
             FMT_THROW(FormatError("invalid format specifier for char"));
-        typedef typename fmt::BasicWriter<Char>::CharPtr CharPtr;
+        typedef typename spdlog::details::fmt::BasicWriter<Char>::CharPtr CharPtr;
         CharPtr out = CharPtr();
         if (spec_.width_ > 1) {
             Char fill = static_cast<Char>(spec_.fill());
             out = writer_.grow_buffer(spec_.width_);
-            if (spec_.align_ == fmt::ALIGN_RIGHT) {
+            if (spec_.align_ == spdlog::details::fmt::ALIGN_RIGHT) {
                 std::fill_n(out, spec_.width_ - 1, fill);
                 out += spec_.width_ - 1;
             }
-            else if (spec_.align_ == fmt::ALIGN_CENTER) {
+            else if (spec_.align_ == spdlog::details::fmt::ALIGN_CENTER) {
                 out = writer_.fill_padding(out, spec_.width_, 1, fill);
             }
             else {
@@ -610,8 +613,8 @@ public:
 
     void visit_pointer(const void *value) {
         if (spec_.type_ && spec_.type_ != 'p')
-            fmt::internal::report_unknown_type(spec_.type_, "pointer");
-        spec_.flags_ = fmt::HASH_FLAG;
+            spdlog::details::fmt::internal::report_unknown_type(spec_.type_, "pointer");
+        spec_.flags_ = spdlog::details::fmt::HASH_FLAG;
         spec_.type_ = 'x';
         writer_.write_int(reinterpret_cast<uintptr_t>(value), spec_);
     }
@@ -623,7 +626,7 @@ public:
 
 template <typename Char>
 template <typename StrChar>
-FMT_FUNC void fmt::BasicWriter<Char>::write_str(
+FMT_FUNC void spdlog::details::fmt::BasicWriter<Char>::write_str(
     const Arg::StringValue<StrChar> &str, const FormatSpec &spec) {
     // Check if StrChar is convertible to Char.
     internal::CharTraits<Char>::convert(StrChar());
@@ -641,7 +644,7 @@ FMT_FUNC void fmt::BasicWriter<Char>::write_str(
 }
 
 template <typename Char>
-inline Arg fmt::BasicFormatter<Char>::parse_arg_index(const Char *&s) {
+inline Arg spdlog::details::fmt::BasicFormatter<Char>::parse_arg_index(const Char *&s) {
     const char *error = 0;
     Arg arg = *s < '0' || *s > '9' ?
               next_arg(error) : get_arg(parse_nonnegative_int(s), error);
@@ -652,7 +655,7 @@ inline Arg fmt::BasicFormatter<Char>::parse_arg_index(const Char *&s) {
     return arg;
 }
 
-FMT_FUNC Arg fmt::internal::FormatterBase::do_get_arg(
+FMT_FUNC Arg spdlog::details::fmt::internal::FormatterBase::do_get_arg(
     unsigned arg_index, const char *&error) {
     Arg arg = args_[arg_index];
     if (arg.type == Arg::NONE)
@@ -660,14 +663,14 @@ FMT_FUNC Arg fmt::internal::FormatterBase::do_get_arg(
     return arg;
 }
 
-inline Arg fmt::internal::FormatterBase::next_arg(const char *&error) {
+inline Arg spdlog::details::fmt::internal::FormatterBase::next_arg(const char *&error) {
     if (next_arg_index_ >= 0)
         return do_get_arg(next_arg_index_++, error);
     error = "cannot switch from manual to automatic argument indexing";
     return Arg();
 }
 
-inline Arg fmt::internal::FormatterBase::get_arg(
+inline Arg spdlog::details::fmt::internal::FormatterBase::get_arg(
     unsigned arg_index, const char *&error) {
     if (next_arg_index_ <= 0) {
         next_arg_index_ = -1;
@@ -678,7 +681,7 @@ inline Arg fmt::internal::FormatterBase::get_arg(
 }
 
 template <typename Char>
-FMT_FUNC void fmt::internal::PrintfFormatter<Char>::parse_flags(
+FMT_FUNC void spdlog::details::fmt::internal::PrintfFormatter<Char>::parse_flags(
     FormatSpec &spec, const Char *&s) {
     for (;;) {
         switch (*s++) {
@@ -705,7 +708,7 @@ FMT_FUNC void fmt::internal::PrintfFormatter<Char>::parse_flags(
 }
 
 template <typename Char>
-FMT_FUNC Arg fmt::internal::PrintfFormatter<Char>::get_arg(
+FMT_FUNC Arg spdlog::details::fmt::internal::PrintfFormatter<Char>::get_arg(
     const Char *s, unsigned arg_index) {
     const char *error = 0;
     Arg arg = arg_index == UINT_MAX ?
@@ -716,7 +719,7 @@ FMT_FUNC Arg fmt::internal::PrintfFormatter<Char>::get_arg(
 }
 
 template <typename Char>
-FMT_FUNC unsigned fmt::internal::PrintfFormatter<Char>::parse_header(
+FMT_FUNC unsigned spdlog::details::fmt::internal::PrintfFormatter<Char>::parse_header(
     const Char *&s, FormatSpec &spec) {
     unsigned arg_index = UINT_MAX;
     Char c = *s;
@@ -752,7 +755,7 @@ FMT_FUNC unsigned fmt::internal::PrintfFormatter<Char>::parse_header(
 }
 
 template <typename Char>
-FMT_FUNC void fmt::internal::PrintfFormatter<Char>::format(
+FMT_FUNC void spdlog::details::fmt::internal::PrintfFormatter<Char>::format(
     BasicWriter<Char> &writer, BasicStringRef<Char> format,
     const ArgList &args) {
     const Char *start = format.c_str();
@@ -806,7 +809,7 @@ FMT_FUNC void fmt::internal::PrintfFormatter<Char>::format(
             break;
         case 'l':
             if (*s == 'l')
-                ArgConverter<fmt::LongLong>(arg, *++s).visit(arg);
+                ArgConverter<spdlog::details::fmt::LongLong>(arg, *++s).visit(arg);
             else
                 ArgConverter<long>(arg, *s).visit(arg);
             break;
@@ -923,7 +926,7 @@ FMT_FUNC void fmt::internal::PrintfFormatter<Char>::format(
 }
 
 template <typename Char>
-FMT_FUNC const Char *fmt::BasicFormatter<Char>::format(
+FMT_FUNC const Char *spdlog::details::fmt::BasicFormatter<Char>::format(
     const Char *&format_str, const Arg &arg) {
     const Char *s = format_str;
     FormatSpec spec;
@@ -1063,7 +1066,7 @@ FMT_FUNC const Char *fmt::BasicFormatter<Char>::format(
 }
 
 template <typename Char>
-FMT_FUNC void fmt::BasicFormatter<Char>::format(
+FMT_FUNC void spdlog::details::fmt::BasicFormatter<Char>::format(
     BasicStringRef<Char> format_str, const ArgList &args) {
     const Char *s = start_ = format_str.c_str();
     set_args(args);
@@ -1084,35 +1087,35 @@ FMT_FUNC void fmt::BasicFormatter<Char>::format(
     write(writer_, start_, s);
 }
 
-FMT_FUNC void fmt::report_system_error(
-    int error_code, fmt::StringRef message) FMT_NOEXCEPT(true) {
+FMT_FUNC void spdlog::details::fmt::report_system_error(
+    int error_code, spdlog::details::fmt::StringRef message) FMT_NOEXCEPT(true) {
     report_error(internal::format_system_error, error_code, message);
 }
 
 #ifdef _WIN32
-FMT_FUNC void fmt::report_windows_error(
-    int error_code, fmt::StringRef message) FMT_NOEXCEPT(true) {
+FMT_FUNC void spdlog::details::fmt::report_windows_error(
+    int error_code, spdlog::details::fmt::StringRef message) FMT_NOEXCEPT(true) {
     report_error(internal::format_windows_error, error_code, message);
 }
 #endif
 
-FMT_FUNC void fmt::print(std::FILE *f, StringRef format_str, ArgList args) {
+FMT_FUNC void spdlog::details::fmt::print(std::FILE *f, StringRef format_str, ArgList args) {
     MemoryWriter w;
     w.write(format_str, args);
     std::fwrite(w.data(), 1, w.size(), f);
 }
 
-FMT_FUNC void fmt::print(StringRef format_str, ArgList args) {
+FMT_FUNC void spdlog::details::fmt::print(StringRef format_str, ArgList args) {
     print(stdout, format_str, args);
 }
 
-FMT_FUNC void fmt::print(std::ostream &os, StringRef format_str, ArgList args) {
+FMT_FUNC void spdlog::details::fmt::print(std::ostream &os, StringRef format_str, ArgList args) {
     MemoryWriter w;
     w.write(format_str, args);
     os.write(w.data(), w.size());
 }
 
-FMT_FUNC void fmt::print_colored(Color c, StringRef format, ArgList args) {
+FMT_FUNC void spdlog::details::fmt::print_colored(Color c, StringRef format, ArgList args) {
     char escape[] = "\x1b[30m";
     escape[3] = '0' + static_cast<char>(c);
     std::fputs(escape, stdout);
@@ -1120,7 +1123,7 @@ FMT_FUNC void fmt::print_colored(Color c, StringRef format, ArgList args) {
     std::fputs(RESET_COLOR, stdout);
 }
 
-FMT_FUNC int fmt::fprintf(std::FILE *f, StringRef format, ArgList args) {
+FMT_FUNC int spdlog::details::fmt::fprintf(std::FILE *f, StringRef format, ArgList args) {
     MemoryWriter w;
     printf(w, format, args);
     std::size_t size = w.size();
@@ -1129,40 +1132,40 @@ FMT_FUNC int fmt::fprintf(std::FILE *f, StringRef format, ArgList args) {
 
 // Explicit instantiations for char.
 
-template const char *fmt::BasicFormatter<char>::format(
-    const char *&format_str, const fmt::internal::Arg &arg);
+template const char *spdlog::details::fmt::BasicFormatter<char>::format(
+    const char *&format_str, const spdlog::details::fmt::internal::Arg &arg);
 
-template void fmt::BasicFormatter<char>::format(
+template void spdlog::details::fmt::BasicFormatter<char>::format(
     BasicStringRef<char> format, const ArgList &args);
 
-template void fmt::internal::PrintfFormatter<char>::format(
+template void spdlog::details::fmt::internal::PrintfFormatter<char>::format(
     BasicWriter<char> &writer, BasicStringRef<char> format, const ArgList &args);
 
-template int fmt::internal::CharTraits<char>::format_float(
+template int spdlog::details::fmt::internal::CharTraits<char>::format_float(
     char *buffer, std::size_t size, const char *format,
     unsigned width, int precision, double value);
 
-template int fmt::internal::CharTraits<char>::format_float(
+template int spdlog::details::fmt::internal::CharTraits<char>::format_float(
     char *buffer, std::size_t size, const char *format,
     unsigned width, int precision, long double value);
 
 // Explicit instantiations for wchar_t.
 
-template const wchar_t *fmt::BasicFormatter<wchar_t>::format(
-    const wchar_t *&format_str, const fmt::internal::Arg &arg);
+template const wchar_t *spdlog::details::fmt::BasicFormatter<wchar_t>::format(
+    const wchar_t *&format_str, const spdlog::details::fmt::internal::Arg &arg);
 
-template void fmt::BasicFormatter<wchar_t>::format(
+template void spdlog::details::fmt::BasicFormatter<wchar_t>::format(
     BasicStringRef<wchar_t> format, const ArgList &args);
 
-template void fmt::internal::PrintfFormatter<wchar_t>::format(
+template void spdlog::details::fmt::internal::PrintfFormatter<wchar_t>::format(
     BasicWriter<wchar_t> &writer, BasicStringRef<wchar_t> format,
     const ArgList &args);
 
-template int fmt::internal::CharTraits<wchar_t>::format_float(
+template int spdlog::details::fmt::internal::CharTraits<wchar_t>::format_float(
     wchar_t *buffer, std::size_t size, const wchar_t *format,
     unsigned width, int precision, double value);
 
-template int fmt::internal::CharTraits<wchar_t>::format_float(
+template int spdlog::details::fmt::internal::CharTraits<wchar_t>::format_float(
     wchar_t *buffer, std::size_t size, const wchar_t *format,
     unsigned width, int precision, long double value);
 
diff --git a/include/spdlog/details/format.h b/include/spdlog/details/format.h
index 82f65058..337b4ab8 100644
--- a/include/spdlog/details/format.h
+++ b/include/spdlog/details/format.h
@@ -115,7 +115,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName) \
   TypeName(const TypeName&); \
   void operator=(const TypeName&)
-
+namespace spdlog {
+namespace details {
 namespace fmt
 {
 
@@ -1053,7 +1054,7 @@ public:
         {
         default:
             assert(false);
-            // Fall through.
+        // Fall through.
         case Arg::INT:
             return FMT_DISPATCH(visit_int(arg.int_value));
         case Arg::UINT:
@@ -2222,7 +2223,7 @@ void BasicWriter<Char>::write_double(
         // MSVC's printf doesn't support 'F'.
         type = 'f';
 #endif
-        // Fall through.
+    // Fall through.
     case 'E':
     case 'G':
     case 'A':
@@ -2739,7 +2740,9 @@ inline void format_decimal(char *&buffer, T value)
     internal::format_decimal(buffer, abs_value, num_digits);
     buffer += num_digits;
 }
-}
+} // ns fmt
+} // ns deatils
+} // ns spdlog
 
 #if FMT_GCC_VERSION
 // Use the system_header pragma to suppress warnings about variadic macros
@@ -2846,6 +2849,8 @@ fmt::print(format, args...);
 #define FMT_VARIADIC_W(ReturnType, func, ...) \
   FMT_VARIADIC_(wchar_t, ReturnType, func, return func, __VA_ARGS__)
 
+namespace spdlog {
+namespace details {
 namespace fmt
 {
 FMT_VARIADIC(std::string, format, StringRef)
@@ -2858,6 +2863,8 @@ FMT_VARIADIC(std::string, sprintf, StringRef)
 FMT_VARIADIC(int, printf, StringRef)
 FMT_VARIADIC(int, fprintf, std::FILE *, StringRef)
 }
+}
+}
 
 // Restore warnings.
 #if FMT_GCC_VERSION >= 406
diff --git a/include/spdlog/details/pattern_formatter_impl.h b/include/spdlog/details/pattern_formatter_impl.h
index 0d36da0d..1b31ced4 100644
--- a/include/spdlog/details/pattern_formatter_impl.h
+++ b/include/spdlog/details/pattern_formatter_impl.h
@@ -458,7 +458,7 @@ inline void spdlog::pattern_formatter::handle_flag(char flag)
 {
     switch (flag)
     {
-        // logger name
+    // logger name
     case 'n':
         _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::name_formatter()));
         break;
@@ -582,8 +582,8 @@ inline void spdlog::pattern_formatter::format(details::log_msg& msg)
         //write eol
         msg.formatted << details::os::eol();
     }
-    catch(const fmt::FormatError& e)
+    catch(const details::fmt::FormatError& e)
     {
-        throw spdlog_ex(fmt::format("formatting error while processing format string: {}", e.what()));
+        throw spdlog_ex(details::fmt::format("formatting error while processing format string: {}", e.what()));
     }
 }
diff --git a/include/spdlog/sinks/file_sinks.h b/include/spdlog/sinks/file_sinks.h
index 26d5d0e1..37a3abc7 100644
--- a/include/spdlog/sinks/file_sinks.h
+++ b/include/spdlog/sinks/file_sinks.h
@@ -99,7 +99,7 @@ protected:
 private:
     static std::string calc_filename(const std::string& filename, std::size_t index, const std::string& extension)
     {
-        fmt::MemoryWriter w;
+        details::fmt::MemoryWriter w;
         if (index)
             w.write("{}.{}.{}", filename, index, extension);
         else
@@ -196,7 +196,7 @@ private:
     static std::string calc_filename(const std::string& basename, const std::string& extension)
     {
         std::tm tm = spdlog::details::os::localtime();
-        fmt::MemoryWriter w;
+        details::fmt::MemoryWriter w;
         w.write("{}.{:04d}-{:02d}-{:02d}.{}", basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, extension);
         return w.str();
     }