Index: uspace/lib/cpp/include/cassert
===================================================================
--- uspace/lib/cpp/include/cassert	(revision 6d8a63a42e5722a9ca3bb5d4e5ff8dba103e8a5e)
+++ uspace/lib/cpp/include/cassert	(revision de531389c322cef1786b1778fe09191b13780aab)
@@ -1,4 +1,4 @@
 /*
- * Copyright (c) 2017 Jaroslav Jindrak
+ * Copyright (c) 2018 Jaroslav Jindrak
  * All rights reserved.
  *
@@ -32,11 +32,15 @@
 #include "internal/common.hpp"
 
+namespace std::hel
+{
+    extern "C" {
+        #include <assert.h>
+    }
+}
+
 namespace std
 {
-
-extern "C" {
-#include <assert.h>
-}
-
+    // Note: The only thing imported is assert
+    //       and that is a macro.
 }
 
Index: uspace/lib/cpp/include/cctype
===================================================================
--- uspace/lib/cpp/include/cctype	(revision 6d8a63a42e5722a9ca3bb5d4e5ff8dba103e8a5e)
+++ uspace/lib/cpp/include/cctype	(revision de531389c322cef1786b1778fe09191b13780aab)
@@ -1,4 +1,4 @@
 /*
- * Copyright (c) 2017 Jaroslav Jindrak
+ * Copyright (c) 2018 Jaroslav Jindrak
  * All rights reserved.
  *
@@ -32,11 +32,27 @@
 #include "internal/common.hpp"
 
+namespace std::hel
+{
+    extern "C" {
+        #include <ctype.h>
+    }
+}
+
 namespace std
 {
-
-extern "C" {
-#include <ctype.h>
-}
-
+    using std::hel::isalnum;
+    using std::hel::isalpha;
+    using std::hel::islower;
+    using std::hel::isupper;
+    using std::hel::isdigit;
+    /* using std::hel::isxdigit; */
+    /* using std::hel::iscntrl; */
+    /* using std::hel::isgraph; */
+    using std::hel::isspace;
+    /* using std::hel::isblank; */
+    /* using std::hel::isprint; */
+    /* using std::hel::ispunct; */
+    using std::hel::tolower;
+    using std::hel::toupper;
 }
 
Index: uspace/lib/cpp/include/cerrno
===================================================================
--- uspace/lib/cpp/include/cerrno	(revision 6d8a63a42e5722a9ca3bb5d4e5ff8dba103e8a5e)
+++ uspace/lib/cpp/include/cerrno	(revision de531389c322cef1786b1778fe09191b13780aab)
@@ -1,4 +1,4 @@
 /*
- * Copyright (c) 2017 Jaroslav Jindrak
+ * Copyright (c) 2018 Jaroslav Jindrak
  * All rights reserved.
  *
@@ -32,11 +32,14 @@
 #include "internal/common.hpp"
 
+namespace std::hel
+{
+    extern "C" {
+        #include <errno.h>
+    }
+}
+
 namespace std
 {
-
-extern "C" {
-#include <errno.h>
-}
-
+    // Note: Only macros are imported here.
 }
 
Index: uspace/lib/cpp/include/cinttypes
===================================================================
--- uspace/lib/cpp/include/cinttypes	(revision 6d8a63a42e5722a9ca3bb5d4e5ff8dba103e8a5e)
+++ uspace/lib/cpp/include/cinttypes	(revision de531389c322cef1786b1778fe09191b13780aab)
@@ -1,7 +1,7 @@
 /*
- * Copyright (c) 2017 Jaroslav Jindrak
+ * Copyright (c) 2018 Jaroslav Jindrak
  * All rights reserved.
  *
- * Redistribution and use in source and binary forms, with or without
+ * Redistribution and using in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
@@ -12,5 +12,5 @@
  *   notice, this list of conditions and the following disclaimer in the
  *   documentation and/or other materials provided with the distribution.
- * - The name of the author may not be used to endorse or promote products
+ * - The name of the author may not be usingd to endorse or promote products
  *   derived from this software without specific prior written permission.
  *
@@ -32,12 +32,35 @@
 #include "internal/common.hpp"
 
+namespace std::hel
+{
+    extern "C" {
+        #include <inttypes.h>
+    }
+}
+
 namespace std
 {
-
-extern "C" {
-#include <inttypes.h>
+    using std::hel::imaxdiv_t;
+    /* using std::hel::abs; */
+    /* using std::hel::div; */
+    /* using std::hel::imaxabs; */
+    /* using std::hel::imaxdiv; */
+    /* using std::hel::strtoimax; */
+    /* using std::hel::strtoumax; */
+    /* using std::hel::wcstoimax; */
+    /* using std::hel::wcstoumax; */
 }
 
-}
+using std::hel::imaxdiv_t;
+/* using std::hel::abs; */
+/* using std::hel::div; */
+/* using std::hel::imaxabs; */
+/* using std::hel::imaxdiv; */
+/* using std::hel::strtoimax; */
+/* using std::hel::strtoumax; */
+/* using std::hel::wcstoimax; */
+/* using std::hel::wcstoumax; */
+
+#include <cstdint>
 
 #endif
Index: uspace/lib/cpp/include/climits
===================================================================
--- uspace/lib/cpp/include/climits	(revision 6d8a63a42e5722a9ca3bb5d4e5ff8dba103e8a5e)
+++ uspace/lib/cpp/include/climits	(revision de531389c322cef1786b1778fe09191b13780aab)
@@ -1,4 +1,4 @@
 /*
- * Copyright (c) 2017 Jaroslav Jindrak
+ * Copyright (c) 2018 Jaroslav Jindrak
  * All rights reserved.
  *
@@ -32,11 +32,14 @@
 #include "internal/common.hpp"
 
+namespace std::hel
+{
+    extern "C" {
+        #include <limits.h>
+    }
+}
+
 namespace std
 {
-
-extern "C" {
-#include <limits.h>
-}
-
+    // Note: Only macros imported here.
 }
 
Index: uspace/lib/cpp/include/csetjmp
===================================================================
--- uspace/lib/cpp/include/csetjmp	(revision 6d8a63a42e5722a9ca3bb5d4e5ff8dba103e8a5e)
+++ uspace/lib/cpp/include/csetjmp	(revision de531389c322cef1786b1778fe09191b13780aab)
@@ -1,4 +1,4 @@
 /*
- * Copyright (c) 2017 Jaroslav Jindrak
+ * Copyright (c) 2018 Jaroslav Jindrak
  * All rights reserved.
  *
@@ -32,12 +32,19 @@
 #include "internal/common.hpp"
 
+namespace std::hel
+{
+    extern "C" {
+        #include <setjmp.h>
+    }
+}
+
 namespace std
 {
-
-extern "C" {
-#include <setjmp.h>
+    using std::hel::jmp_buf;
+    using std::hel::longjmp;
 }
 
-}
+using std::hel::jmp_buf;
+using std::hel::longjmp;
 
 #endif
Index: uspace/lib/cpp/include/cstdarg
===================================================================
--- uspace/lib/cpp/include/cstdarg	(revision 6d8a63a42e5722a9ca3bb5d4e5ff8dba103e8a5e)
+++ uspace/lib/cpp/include/cstdarg	(revision de531389c322cef1786b1778fe09191b13780aab)
@@ -1,4 +1,4 @@
 /*
- * Copyright (c) 2017 Jaroslav Jindrak
+ * Copyright (c) 2018 Jaroslav Jindrak
  * All rights reserved.
  *
@@ -32,12 +32,17 @@
 #include "internal/common.hpp"
 
+namespace std::hel
+{
+    extern "C" {
+        #include <stdarg.h>
+    }
+}
+
 namespace std
 {
-
-extern "C" {
-#include <stdarg.h>
+    using std::hel::va_list;
 }
 
-}
+using std::hel::va_list;
 
 #endif
Index: uspace/lib/cpp/include/cstddef
===================================================================
--- uspace/lib/cpp/include/cstddef	(revision 6d8a63a42e5722a9ca3bb5d4e5ff8dba103e8a5e)
+++ uspace/lib/cpp/include/cstddef	(revision de531389c322cef1786b1778fe09191b13780aab)
@@ -1,4 +1,4 @@
 /*
- * Copyright (c) 2017 Jaroslav Jindrak
+ * Copyright (c) 2018 Jaroslav Jindrak
  * All rights reserved.
  *
@@ -32,14 +32,25 @@
 #include "internal/common.hpp"
 
+namespace std::hel
+{
+    extern "C" {
+        #include <stddef.h>
+    }
+}
+
+
 namespace std
 {
+    using nullptr_t = decltype(nullptr);
 
-extern "C" {
-#include <stddef.h>
+    using std::hel::size_t;
+    using std::hel::ptrdiff_t;
+    /* using std::hel::max_align_t; */
 }
 
-using nullptr_t = decltype(nullptr);
-
-}
+using std::nullptr_t;
+using std::hel::size_t;
+using std::hel::ptrdiff_t;
+/* using std::hel::max_align_t; */
 
 #endif
Index: uspace/lib/cpp/include/cstdint
===================================================================
--- uspace/lib/cpp/include/cstdint	(revision 6d8a63a42e5722a9ca3bb5d4e5ff8dba103e8a5e)
+++ uspace/lib/cpp/include/cstdint	(revision de531389c322cef1786b1778fe09191b13780aab)
@@ -1,4 +1,4 @@
 /*
- * Copyright (c) 2017 Jaroslav Jindrak
+ * Copyright (c) 2018 Jaroslav Jindrak
  * All rights reserved.
  *
@@ -32,31 +32,48 @@
 #include "internal/common.hpp"
 
+namespace std::hel
+{
+    extern "C" {
+        #include <stdint.h>
+    }
+}
+
 namespace std
 {
+    using int8_t  = std::hel::int8_t;
+    using int16_t = std::hel::int16_t;
+    using int32_t = std::hel::int32_t;
+    using int64_t = std::hel::int64_t;
 
-extern "C" {
-#include <stdint.h>
-}
+    using intmax_t = std::hel::intmax_t;
+    using intptr_t = std::hel::intptr_t;
 
-using int_fast8_t  = int8_t;
-using int_fast16_t = int16_t;
-using int_fast32_t = int32_t;
-using int_fast64_t = int64_t;
+    using int_fast8_t  = std::hel::int8_t;
+    using int_fast16_t = std::hel::int16_t;
+    using int_fast32_t = std::hel::int32_t;
+    using int_fast64_t = std::hel::int64_t;
 
-using int_least8_t  = int8_t;
-using int_least16_t = int16_t;
-using int_least32_t = int32_t;
-using int_least64_t = int64_t;
+    using int_least8_t  = std::hel::int8_t;
+    using int_least16_t = std::hel::int16_t;
+    using int_least32_t = std::hel::int32_t;
+    using int_least64_t = std::hel::int64_t;
 
-using uint_fast8_t  = uint8_t;
-using uint_fast16_t = uint16_t;
-using uint_fast32_t = uint32_t;
-using uint_fast64_t = uint64_t;
+    using uint8_t  = std::hel::uint8_t;
+    using uint16_t = std::hel::uint16_t;
+    using uint32_t = std::hel::uint32_t;
+    using uint64_t = std::hel::uint64_t;
 
-using uint_least8_t  = uint8_t;
-using uint_least16_t = uint16_t;
-using uint_least32_t = uint32_t;
-using uint_least64_t = uint64_t;
+    using uintmax_t = std::hel::uintmax_t;
+    using uintptr_t = std::hel::uintptr_t;
 
+    using uint_fast8_t  = std::hel::uint8_t;
+    using uint_fast16_t = std::hel::uint16_t;
+    using uint_fast32_t = std::hel::uint32_t;
+    using uint_fast64_t = std::hel::uint64_t;
+
+    using uint_least8_t  = std::hel::uint8_t;
+    using uint_least16_t = std::hel::uint16_t;
+    using uint_least32_t = std::hel::uint32_t;
+    using uint_least64_t = std::hel::uint64_t;
 }
 
Index: uspace/lib/cpp/include/cstdio
===================================================================
--- uspace/lib/cpp/include/cstdio	(revision 6d8a63a42e5722a9ca3bb5d4e5ff8dba103e8a5e)
+++ uspace/lib/cpp/include/cstdio	(revision de531389c322cef1786b1778fe09191b13780aab)
@@ -1,4 +1,4 @@
 /*
- * Copyright (c) 2017 Jaroslav Jindrak
+ * Copyright (c) 2018 Jaroslav Jindrak
  * All rights reserved.
  *
@@ -32,12 +32,111 @@
 #include "internal/common.hpp"
 
+namespace std::hel
+{
+    extern "C" {
+        #include <stdio.h>
+    }
+}
+
 namespace std
 {
+    using std::hel::FILE;
+    /* using std::hel::fpos_t */
+    using std::hel::size_t;
 
-extern "C" {
-#include <stdio.h>
+    using std::hel::clearerr;
+    using std::hel::fclose;
+    using std::hel::feof;
+    using std::hel::ferror;
+    using std::hel::fflush;
+    using std::hel::fgetc;
+    /* using std::hel::fgetpos; */
+    using std::hel::fgets;
+    using std::hel::fopen;
+    using std::hel::fprintf;
+    using std::hel::fputc;
+    using std::hel::fputs;
+    using std::hel::fread;
+    using std::hel::freopen;
+    /* using std::hel::fscanf; */
+    using std::hel::fseek;
+    /* using std::hel::fsetpos; */
+    using std::hel::ftell;
+    using std::hel::fwrite;
+    /* using std::hel::getc; */
+    using std::hel::getchar;
+    /* using std::hel::perror; */
+    using std::hel::printf;
+    /* using std::hel::putc; */
+    using std::hel::putchar;
+    using std::hel::puts;
+    using std::hel::remove;
+    using std::hel::rename;
+    using std::hel::rewind;
+    /* using std::hel::scanf; */
+    using std::hel::setbuf;
+    using std::hel::setvbuf;
+    using std::hel::snprintf;
+    /* using std::hel::sprintf; */
+    /* using std::hel::sscanf; */
+    /* using std::hel::tmpfile; */
+    /* using std::hel::tmpnam; */
+    using std::hel::ungetc;
+    using std::hel::vfprintf;
+    using std::hel::vprintf;
+    /* using std::hel::vscanf; */
+    using std::hel::vsnprintf;
+    /* using std::hel::vsprintf; */
+    /* using std::hel::vsscanf; */
 }
 
-}
+using std::hel::FILE;
+/* using std::hel::fpos_t */
+using std::hel::size_t;
+
+using std::hel::clearerr;
+using std::hel::fclose;
+using std::hel::feof;
+using std::hel::ferror;
+using std::hel::fflush;
+using std::hel::fgetc;
+/* using std::hel::fgetpos; */
+using std::hel::fgets;
+using std::hel::fopen;
+using std::hel::fprintf;
+using std::hel::fputc;
+using std::hel::fputs;
+using std::hel::fread;
+using std::hel::freopen;
+/* using std::hel::fscanf; */
+using std::hel::fseek;
+/* using std::hel::fsetpos; */
+using std::hel::ftell;
+using std::hel::fwrite;
+/* using std::hel::getc; */
+using std::hel::getchar;
+/* using std::hel::perror; */
+using std::hel::printf;
+/* using std::hel::putc; */
+using std::hel::putchar;
+using std::hel::puts;
+using std::hel::remove;
+using std::hel::rename;
+using std::hel::rewind;
+/* using std::hel::scanf; */
+using std::hel::setbuf;
+using std::hel::setvbuf;
+using std::hel::snprintf;
+/* using std::hel::sprintf; */
+/* using std::hel::sscanf; */
+/* using std::hel::tmpfile; */
+/* using std::hel::tmpnam; */
+using std::hel::ungetc;
+using std::hel::vfprintf;
+using std::hel::vprintf;
+/* using std::hel::vscanf; */
+using std::hel::vsnprintf;
+/* using std::hel::vsprintf; */
+/* using std::hel::vsscanf; */
 
 #endif
Index: uspace/lib/cpp/include/cstdlib
===================================================================
--- uspace/lib/cpp/include/cstdlib	(revision 6d8a63a42e5722a9ca3bb5d4e5ff8dba103e8a5e)
+++ uspace/lib/cpp/include/cstdlib	(revision de531389c322cef1786b1778fe09191b13780aab)
@@ -1,4 +1,4 @@
 /*
- * Copyright (c) 2017 Jaroslav Jindrak
+ * Copyright (c) 2018 Jaroslav Jindrak
  * All rights reserved.
  *
@@ -32,12 +32,109 @@
 #include "internal/common.hpp"
 
+namespace std::hel
+{
+    extern "C" {
+        #include <stdlib.h>
+    }
+}
+
 namespace std
 {
+    /* using std::hel::div_t; */
+    /* using std::hel::ldiv_t; */
+    /* using std::hel::lldiv_t; */
+    using std::hel::size_t;
 
-extern "C" {
-#include <stdlib.h>
+    using std::hel::abort;
+    using std::hel::exit;
+    /* using std::hel::quick_exit; */
+    /* using std::hel::_Exit; */
+    using std::hel::atexit;
+    /* using std::hel::at_quick_exit; */
+    /* using std::hel::system; */
+    /* using std::hel::getenv; */
+
+    using std::hel::malloc;
+    using std::hel::calloc;
+    using std::hel::realloc;
+    using std::hel::free;
+
+    /* using std::hel::atof; */
+    /* using std::hel::atoi; */
+    /* using std::hel::atol; */
+    /* using std::hel::atoll; */
+    /* using std::hel::strtol; */
+    /* using std::hel::strtoll; */
+    /* using std::hel::strtoul; */
+    /* using std::hel::strtoull; */
+    /* using std::hel::strtof; */
+    /* using std::hel::strtod; */
+    /* using std::hel::strtold; */
+
+    /* using std::hel::mblen; */
+    /* using std::hel::mbtowc; */
+    /* using std::hel::wctomb; */
+    /* using std::hel::mbstowcs; */
+    /* using std::hel::wcstombs; */
+
+    using std::hel::random; // Supposed to be rand.
+    using std::hel::srandom; // Supposed to be srand.
+    using std::hel::qsort;
+    /* using std::hel::bsearch; */
+    /* using std::hel::abs; */
+    /* using std::hel::labs; */
+    /* using std::hel::llabs; */
+    /* using std::hel::div; */
+    /* using std::hel::ldiv; */
+    /* using std::hel::lldiv; */
 }
 
-}
+/* using std::hel::div_t; */
+/* using std::hel::ldiv_t; */
+/* using std::hel::lldiv_t; */
+using std::hel::size_t;
+
+using std::hel::abort;
+using std::hel::exit;
+/* using std::hel::quick_exit; */
+/* using std::hel::_Exit; */
+using std::hel::atexit;
+/* using std::hel::at_quick_exit; */
+/* using std::hel::system; */
+/* using std::hel::getenv; */
+
+using std::hel::malloc;
+using std::hel::calloc;
+using std::hel::realloc;
+using std::hel::free;
+
+/* using std::hel::atof; */
+/* using std::hel::atoi; */
+/* using std::hel::atol; */
+/* using std::hel::atoll; */
+/* using std::hel::strtol; */
+/* using std::hel::strtoll; */
+/* using std::hel::strtoul; */
+/* using std::hel::strtoull; */
+/* using std::hel::strtof; */
+/* using std::hel::strtod; */
+/* using std::hel::strtold; */
+
+/* using std::hel::mblen; */
+/* using std::hel::mbtowc; */
+/* using std::hel::wctomb; */
+/* using std::hel::mbstowcs; */
+/* using std::hel::wcstombs; */
+
+using std::hel::random; // Supposed to be rand.
+using std::hel::srandom; // Supposed to be srand.
+using std::hel::qsort;
+/* using std::hel::bsearch; */
+/* using std::hel::abs; */
+/* using std::hel::labs; */
+/* using std::hel::llabs; */
+/* using std::hel::div; */
+/* using std::hel::ldiv; */
+/* using std::hel::lldiv; */
 
 #endif
Index: uspace/lib/cpp/include/cstring
===================================================================
--- uspace/lib/cpp/include/cstring	(revision 6d8a63a42e5722a9ca3bb5d4e5ff8dba103e8a5e)
+++ uspace/lib/cpp/include/cstring	(revision de531389c322cef1786b1778fe09191b13780aab)
@@ -1,4 +1,4 @@
 /*
- * Copyright (c) 2017 Jaroslav Jindrak
+ * Copyright (c) 2018 Jaroslav Jindrak
  * All rights reserved.
  *
@@ -32,12 +32,69 @@
 #include "internal/common.hpp"
 
+namespace std::hel
+{
+    extern "C" {
+        #include <str.h>
+    }
+}
+
 namespace std
 {
+    using std::hel::size_t;
 
-extern "C" {
-#include <str.h>
+    /* using std::hel::strcpy; */
+    /* using std::hel::strncpy; */
+    /* using std::hel::strcat; */
+    /* using std::hel::strncat; */
+    /* using std::hel::strxfrm; */
+
+    /* using std::hel::strlen; */
+    /* using std::hel::strcmp; */
+    /* using std::hel::strncmp; */
+    /* using std::hel::strcoll; */
+    /* using std::hel::strchr; */
+    /* using std::hel::strrchr; */
+    /* using std::hel::strspn; */
+    /* using std::hel::strcspn; */
+    /* using std::hel::strpbrk; */
+    /* using std::hel::strstr; */
+    /* using std::hel::strok; */
+
+    /* using std::hel::memchr; */
+    using std::hel::memcmp;
+    using std::hel::memset;
+    using std::hel::memcpy;
+    using std::hel::memmove;
+
+    /* using std::hel::strerror; */
 }
 
-}
+using std::hel::size_t;
+
+/* using std::hel::strcpy; */
+/* using std::hel::strncpy; */
+/* using std::hel::strcat; */
+/* using std::hel::strncat; */
+/* using std::hel::strxfrm; */
+
+/* using std::hel::strlen; */
+/* using std::hel::strcmp; */
+/* using std::hel::strncmp; */
+/* using std::hel::strcoll; */
+/* using std::hel::strchr; */
+/* using std::hel::strrchr; */
+/* using std::hel::strspn; */
+/* using std::hel::strcspn; */
+/* using std::hel::strpbrk; */
+/* using std::hel::strstr; */
+/* using std::hel::strok; */
+
+/* using std::hel::memchr; */
+using std::hel::memcmp;
+using std::hel::memset;
+using std::hel::memcpy;
+using std::hel::memmove;
+
+/* using std::hel::strerror; */
 
 #endif
Index: uspace/lib/cpp/include/ctime
===================================================================
--- uspace/lib/cpp/include/ctime	(revision 6d8a63a42e5722a9ca3bb5d4e5ff8dba103e8a5e)
+++ uspace/lib/cpp/include/ctime	(revision de531389c322cef1786b1778fe09191b13780aab)
@@ -1,4 +1,4 @@
 /*
- * Copyright (c) 2017 Jaroslav Jindrak
+ * Copyright (c) 2018 Jaroslav Jindrak
  * All rights reserved.
  *
@@ -32,12 +32,49 @@
 #include "internal/common.hpp"
 
+namespace std::hel
+{
+    extern "C" {
+        #include <time.h>
+    }
+}
+
 namespace std
 {
+    /* using std::hel::clock_t; */
+    using std::hel::size_t;
+    using std::hel::time_t;
+    using std::hel::tm;
+    /* using std::hel::timespec; */
 
-extern "C" {
-#include <time.h>
+    /* using std::hel::clock; */
+    using std::hel::time;
+    using std::hel::difftime;
+
+    /* using std::hel::ctime; */
+    /* using std::hel::asctime; */
+    using std::hel::strftime;
+    /* using std::hel::wcsftime; */
+    /* using std::hel::gmtime; */
+    /* using std::hel::localtime; */
+    using std::hel::mktime;
 }
 
-}
+/* using std::hel::clock_t; */
+using std::hel::size_t;
+using std::hel::time_t;
+using std::hel::tm;
+/* using std::hel::timespec; */
+
+/* using std::hel::clock; */
+using std::hel::time;
+using std::hel::difftime;
+
+/* using std::hel::ctime; */
+/* using std::hel::asctime; */
+using std::hel::strftime;
+/* using std::hel::wcsftime; */
+/* using std::hel::gmtime; */
+/* using std::hel::localtime; */
+using std::hel::mktime;
 
 #endif
Index: uspace/lib/cpp/include/cwchar
===================================================================
--- uspace/lib/cpp/include/cwchar	(revision 6d8a63a42e5722a9ca3bb5d4e5ff8dba103e8a5e)
+++ uspace/lib/cpp/include/cwchar	(revision de531389c322cef1786b1778fe09191b13780aab)
@@ -1,4 +1,4 @@
 /*
- * Copyright (c) 2017 Jaroslav Jindrak
+ * Copyright (c) 2018 Jaroslav Jindrak
  * All rights reserved.
  *
@@ -32,12 +32,148 @@
 #include "internal/common.hpp"
 
+namespace std::hel
+{
+    extern "C" {
+        #include <wchar.h>
+        #include <time.h>
+    }
+}
+
 namespace std
 {
+    /* using std::hel::mbstate_t; */
+    using std::hel::size_t;
+    using std::hel::wint_t;
+    using std::hel::tm;
 
-extern "C" {
-#include <wchar.h>
+    /* using std::hel::wcscpy; */
+    /* using std::hel::wcsncpy; */
+    /* using std::hel::wcscat; */
+    /* using std::hel::wcsncat; */
+    /* using std::hel::wcsnxfrm; */
+
+    /* using std::hel::wcslen; */
+    /* using std::hel::wcscmp; */
+    /* using std::hel::wcsncmp; */
+    /* using std::hel::wcscoll; */
+    /* using std::hel::wcschr; */
+    /* using std::hel::wcsrchr; */
+    /* using std::hel::wcsspn; */
+    /* using std::hel::wcscspn; */
+    /* using std::hel::wcspbrk; */
+    /* using std::hel::wcsstr; */
+    /* using std::hel::wcstok; */
+
+    /* using std::hel::wmemcpy; */
+    /* using std::hel::wmemmove; */
+    /* using std::hel::wmemcmp; */
+    /* using std::hel::wmemchr; */
+    /* using std::hel::wmemset; */
+
+    /* using std::hel::msbinit; */
+    /* using std::hel::btowc; */
+    /* using std::hel::wctob; */
+    /* using std::hel::mbrlen; */
+    /* using std::hel::mbrtowc; */
+    /* using std::hel::wctomb; */
+    /* using std::hel::mbsrtowcs; */
+    /* using std::hel::wcsrtombs; */
+
+    /* using std::hel::fgetwc; */
+    /* using std::hel::getwc; */
+    /* using std::hel::fgetws; */
+    /* using std::hel::fputwc; */
+    /* using std::hel::putwc; */
+    /* using std::hel::fputws; */
+    /* using std::hel::getwchar; */
+    /* using std::hel::putwchar; */
+    /* using std::hel::ungetwc; */
+    /* using std::hel::fwide; */
+    /* using std::hel::wscanf; */
+    /* using std::hel::fwscanf; */
+    /* using std::hel::swscanf; */
+    /* using std::hel::vwscanf; */
+    /* using std::hel::vfwscanf; */
+    /* using std::hel::vswscanf; */
+    /* using std::hel::wprintf; */
+    /* using std::hel::fwprintf; */
+    /* using std::hel::swprintf; */
+
+    /* using std::hel::wcsftime; */
+    /* using std::hel::wcstol; */
+    /* using std::hel::wcstoll; */
+    /* using std::hel::wcstoul; */
+    /* using std::hel::wcstoull; */
+    /* using std::hel::wcstof; */
+    /* using std::hel::wcstod; */
+    /* using std::hel::wcstold; */
 }
 
-}
+/* using std::hel::mbstate_t; */
+using std::hel::size_t;
+using std::hel::wint_t;
+using std::hel::tm;
+
+/* using std::hel::wcscpy; */
+/* using std::hel::wcsncpy; */
+/* using std::hel::wcscat; */
+/* using std::hel::wcsncat; */
+/* using std::hel::wcsnxfrm; */
+
+/* using std::hel::wcslen; */
+/* using std::hel::wcscmp; */
+/* using std::hel::wcsncmp; */
+/* using std::hel::wcscoll; */
+/* using std::hel::wcschr; */
+/* using std::hel::wcsrchr; */
+/* using std::hel::wcsspn; */
+/* using std::hel::wcscspn; */
+/* using std::hel::wcspbrk; */
+/* using std::hel::wcsstr; */
+/* using std::hel::wcstok; */
+
+/* using std::hel::wmemcpy; */
+/* using std::hel::wmemmove; */
+/* using std::hel::wmemcmp; */
+/* using std::hel::wmemchr; */
+/* using std::hel::wmemset; */
+
+/* using std::hel::msbinit; */
+/* using std::hel::btowc; */
+/* using std::hel::wctob; */
+/* using std::hel::mbrlen; */
+/* using std::hel::mbrtowc; */
+/* using std::hel::wctomb; */
+/* using std::hel::mbsrtowcs; */
+/* using std::hel::wcsrtombs; */
+
+/* using std::hel::fgetwc; */
+/* using std::hel::getwc; */
+/* using std::hel::fgetws; */
+/* using std::hel::fputwc; */
+/* using std::hel::putwc; */
+/* using std::hel::fputws; */
+/* using std::hel::getwchar; */
+/* using std::hel::putwchar; */
+/* using std::hel::ungetwc; */
+/* using std::hel::fwide; */
+/* using std::hel::wscanf; */
+/* using std::hel::fwscanf; */
+/* using std::hel::swscanf; */
+/* using std::hel::vwscanf; */
+/* using std::hel::vfwscanf; */
+/* using std::hel::vswscanf; */
+/* using std::hel::wprintf; */
+/* using std::hel::fwprintf; */
+/* using std::hel::swprintf; */
+
+/* using std::hel::wcsftime; */
+/* using std::hel::wcstol; */
+/* using std::hel::wcstoll; */
+/* using std::hel::wcstoul; */
+/* using std::hel::wcstoull; */
+/* using std::hel::wcstof; */
+/* using std::hel::wcstod; */
+/* using std::hel::wcstold; */
 
 #endif
Index: uspace/lib/cpp/include/impl/chrono.hpp
===================================================================
--- uspace/lib/cpp/include/impl/chrono.hpp	(revision 6d8a63a42e5722a9ca3bb5d4e5ff8dba103e8a5e)
+++ uspace/lib/cpp/include/impl/chrono.hpp	(revision de531389c322cef1786b1778fe09191b13780aab)
@@ -611,6 +611,6 @@
             static time_point now()
             {
-                std::timeval tv{};
-                std::gettimeofday(&tv, nullptr);
+                hel::timeval tv{};
+                hel::gettimeofday(&tv, nullptr);
 
                 rep time = tv.tv_usec;
@@ -654,6 +654,6 @@
             static time_point now()
             {
-                std::timeval tv{};
-                std::getuptime(&tv);
+                hel::timeval tv{};
+                hel::getuptime(&tv);
 
                 rep time = tv.tv_usec;
Index: uspace/lib/cpp/include/impl/ios.hpp
===================================================================
--- uspace/lib/cpp/include/impl/ios.hpp	(revision 6d8a63a42e5722a9ca3bb5d4e5ff8dba103e8a5e)
+++ uspace/lib/cpp/include/impl/ios.hpp	(revision de531389c322cef1786b1778fe09191b13780aab)
@@ -41,5 +41,5 @@
 {
     using streamoff = long long;
-    using streamsize = ssize_t;
+    using streamsize = hel::ssize_t;
 
     /**
Index: uspace/lib/cpp/include/impl/iterator.hpp
===================================================================
--- uspace/lib/cpp/include/impl/iterator.hpp	(revision 6d8a63a42e5722a9ca3bb5d4e5ff8dba103e8a5e)
+++ uspace/lib/cpp/include/impl/iterator.hpp	(revision de531389c322cef1786b1778fe09191b13780aab)
@@ -530,5 +530,5 @@
         >
         {
-            using type = remove_reference_t<typename iterator_traits<Iterator>::reference>;
+            using type = remove_reference_t<typename iterator_traits<Iterator>::reference>&&;
         };
     }
Index: uspace/lib/cpp/include/impl/stack.hpp
===================================================================
--- uspace/lib/cpp/include/impl/stack.hpp	(revision 6d8a63a42e5722a9ca3bb5d4e5ff8dba103e8a5e)
+++ uspace/lib/cpp/include/impl/stack.hpp	(revision de531389c322cef1786b1778fe09191b13780aab)
@@ -48,5 +48,5 @@
             using container_type  = Container;
             using value_type      = typename container_type::value_type;
-            using reference       = typename constainer_type::reference;
+            using reference       = typename container_type::reference;
             using const_reference = typename container_type::const_reference;
             using size_type       = typename container_type::size_type;
@@ -132,5 +132,5 @@
 
             void swap(stack& other)
-                noexcept(noexcept(swap(c, other.c)))
+                /* noexcept(noexcept(swap(c, other.c))) */
             {
                 std::swap(c, other.c);
Index: uspace/lib/cpp/include/impl/string.hpp
===================================================================
--- uspace/lib/cpp/include/impl/string.hpp	(revision 6d8a63a42e5722a9ca3bb5d4e5ff8dba103e8a5e)
+++ uspace/lib/cpp/include/impl/string.hpp	(revision de531389c322cef1786b1778fe09191b13780aab)
@@ -44,5 +44,4 @@
 namespace std
 {
-
     /**
      * 21.2, char_traits:
@@ -82,10 +81,10 @@
         static int compare(const char_type* s1, const char_type* s2, size_t n)
         {
-            return std::str_lcmp(s1, s2, n);
+            return hel::str_lcmp(s1, s2, n);
         }
 
         static size_t length(const char_type* s)
         {
-            return std::str_size(s);
+            return hel::str_size(s);
         }
 
@@ -354,5 +353,5 @@
         {
             // TODO: This function does not exits...
-            //return std::wstr_lcmp(s1, s2, n);
+            //return hel::wstr_lcmp(s1, s2, n);
             return 0;
         }
@@ -360,5 +359,5 @@
         static size_t length(const char_type* s)
         {
-            return std::wstr_size(s);
+            return hel::wstr_size(s);
         }
 
@@ -448,5 +447,8 @@
             /**
              * 21.4.2, construct/copy/destroy:
+             * TODO: tagged constructor that moves the char*
+             *       and use that with asprintf in to_string
              */
+
             basic_string() noexcept
                 : basic_string(allocator_type{})
Index: uspace/lib/cpp/include/impl/thread.hpp
===================================================================
--- uspace/lib/cpp/include/impl/thread.hpp	(revision 6d8a63a42e5722a9ca3bb5d4e5ff8dba103e8a5e)
+++ uspace/lib/cpp/include/impl/thread.hpp	(revision de531389c322cef1786b1778fe09191b13780aab)
@@ -248,7 +248,8 @@
             { /* DUMMY BODY */ }
 
-            fid_t id_; // For testing atm public.
         private:
-            id(fid_t id)
+            aux::thread_t id_;
+
+            id(aux::thread_t id)
                 : id_{id}
             { /* DUMMY BODY */ }
Index: uspace/lib/cpp/include/impl/utility.hpp
===================================================================
--- uspace/lib/cpp/include/impl/utility.hpp	(revision 6d8a63a42e5722a9ca3bb5d4e5ff8dba103e8a5e)
+++ uspace/lib/cpp/include/impl/utility.hpp	(revision de531389c322cef1786b1778fe09191b13780aab)
@@ -30,4 +30,5 @@
 #define LIBCPP_UTILITY
 
+#include <cstdint>
 #include <type_traits>
 
@@ -78,6 +79,4 @@
     constexpr T&& forward(remove_reference_t<T>&& t) noexcept
     {
-        // TODO: check if t is lvalue reference, if it is, the program
-        //       is ill-formed according to the standard
         return static_cast<T&&>(t);
     }
@@ -236,5 +235,5 @@
     namespace aux
     {
-        template<class T, std::uintmax_t N>
+        template<class T, uintmax_t N>
         struct make_integer_sequence
         {
Index: uspace/lib/cpp/include/internal/thread.hpp
===================================================================
--- uspace/lib/cpp/include/internal/thread.hpp	(revision 6d8a63a42e5722a9ca3bb5d4e5ff8dba103e8a5e)
+++ uspace/lib/cpp/include/internal/thread.hpp	(revision de531389c322cef1786b1778fe09191b13780aab)
@@ -30,6 +30,6 @@
 #define LIBCPP_INTERNAL_THREAD
 
-namespace std
-{ // TODO: fix cheaders
+namespace std::hel
+{
     extern "C" {
         #include <fibril.h>
@@ -54,9 +54,9 @@
     struct threading_policy<fibril_tag>
     {
-        using mutex_type        = fibril_mutex_t;
-        using thread_type       = fid_t;
-        using condvar_type      = fibril_condvar_t;
-        using time_unit         = suseconds_t;
-        using shared_mutex_type = fibril_rwlock_t;
+        using mutex_type        = hel::fibril_mutex_t;
+        using thread_type       = hel::fid_t;
+        using condvar_type      = hel::fibril_condvar_t;
+        using time_unit         = hel::suseconds_t;
+        using shared_mutex_type = hel::fibril_rwlock_t;
 
         struct thread
@@ -65,20 +65,20 @@
             static thread_type create(Callable clbl, Payload& pld)
             {
-                return fibril_create(clbl, (void*)&pld);
+                return hel::fibril_create(clbl, (void*)&pld);
             }
 
             static void start(thread_type thr)
             {
-                fibril_add_ready(thr);
+                hel::fibril_add_ready(thr);
             }
 
             static thread_type this_thread()
             {
-                return fibril_get_id();
+                return hel::fibril_get_id();
             }
 
             static void yield()
             {
-                fibril_yield();
+                hel::fibril_yield();
             }
 
@@ -94,20 +94,20 @@
             static void init(mutex_type& mtx)
             {
-                fibril_mutex_initialize(&mtx);
+                hel::fibril_mutex_initialize(&mtx);
             }
 
             static void lock(mutex_type& mtx)
             {
-                fibril_mutex_lock(&mtx);
+                hel::fibril_mutex_lock(&mtx);
             }
 
             static void unlock(mutex_type& mtx)
             {
-                fibril_mutex_unlock(&mtx);
+                hel::fibril_mutex_unlock(&mtx);
             }
 
             static bool try_lock(mutex_type& mtx)
             {
-                return fibril_mutex_trylock(&mtx);
+                return hel::fibril_mutex_trylock(&mtx);
             }
 
@@ -123,25 +123,25 @@
             static void init(condvar_type& cv)
             {
-                fibril_condvar_initialize(&cv);
+                hel::fibril_condvar_initialize(&cv);
             }
 
             static void wait(condvar_type& cv, mutex_type& mtx)
             {
-                fibril_condvar_wait(&cv, &mtx);
+                hel::fibril_condvar_wait(&cv, &mtx);
             }
 
             static int wait_for(condvar_type& cv, mutex_type& mtx, time_unit timeout)
             {
-                return fibril_condvar_wait_timeout(&cv, &mtx, timeout);
+                return hel::fibril_condvar_wait_timeout(&cv, &mtx, timeout);
             }
 
             static void signal(condvar_type& cv)
             {
-                fibril_condvar_signal(&cv);
+                hel::fibril_condvar_signal(&cv);
             }
 
             static void broadcast(condvar_type& cv)
             {
-                fibril_condvar_broadcast(&cv);
+                hel::fibril_condvar_broadcast(&cv);
             }
         };
@@ -157,5 +157,5 @@
             static void sleep(time_unit time)
             {
-                fibril_usleep(time);
+                hel::fibril_usleep(time);
             }
         };
@@ -165,25 +165,25 @@
             static void init(shared_mutex_type& mtx)
             {
-                fibril_rwlock_initialize(&mtx);
+                hel::fibril_rwlock_initialize(&mtx);
             }
 
             static void lock(shared_mutex_type& mtx)
             {
-                fibril_rwlock_write_lock(&mtx);
+                hel::fibril_rwlock_write_lock(&mtx);
             }
 
             static void unlock(shared_mutex_type& mtx)
             {
-                fibril_rwlock_write_unlock(&mtx);
+                hel::fibril_rwlock_write_unlock(&mtx);
             }
 
             static void lock_shared(shared_mutex_type& mtx)
             {
-                fibril_rwlock_read_lock(&mtx);
+                hel::fibril_rwlock_read_lock(&mtx);
             }
 
             static void unlock_shared(shared_mutex_type& mtx)
             {
-                fibril_rwlock_read_unlock(&mtx);
+                hel::fibril_rwlock_read_unlock(&mtx);
             }