Index: uspace/lib/cpp/Makefile
===================================================================
--- uspace/lib/cpp/Makefile	(revision 17c41c37362dddb20eba6f84eece106fe2a0c71b)
+++ uspace/lib/cpp/Makefile	(revision 0d221d2827fc28ca8e9907c4bd67482237688824)
@@ -46,4 +46,5 @@
 	src/mutex.cpp \
 	src/new.cpp \
+	src/stdexcept.cpp \
 	src/string.cpp \
 	src/system_error.cpp \
Index: uspace/lib/cpp/include/impl/stdexcept.hpp
===================================================================
--- uspace/lib/cpp/include/impl/stdexcept.hpp	(revision 17c41c37362dddb20eba6f84eece106fe2a0c71b)
+++ uspace/lib/cpp/include/impl/stdexcept.hpp	(revision 0d221d2827fc28ca8e9907c4bd67482237688824)
@@ -30,5 +30,96 @@
 #define LIBCPP_STDEXCEPT
 
-#error "<stdexcept> is not implemented"
+#include <exception>
+#include <iosfwd>
+#include <internal/stringfwd.hpp>
+
+namespace std
+{
+    class logic_error: public exception
+    {
+        public:
+            explicit logic_error(const string&);
+            explicit logic_error(const char*);
+            logic_error(const logic_error&) noexcept;
+            logic_error& operator=(const logic_error&);
+            ~logic_error() override;
+
+            const char* what() const noexcept override;
+
+        protected:
+            const char* what_;
+    };
+
+    class domain_error: public logic_error
+    {
+        public:
+            explicit domain_error(const string&);
+            explicit domain_error(const char*);
+            domain_error(const domain_error&) noexcept;
+    };
+
+    class invalid_argument: public logic_error
+    {
+        public:
+            explicit invalid_argument(const string&);
+            explicit invalid_argument(const char*);
+            invalid_argument(const invalid_argument&) noexcept;
+    };
+
+    class length_error: public logic_error
+    {
+        public:
+            explicit length_error(const string&);
+            explicit length_error(const char*);
+            length_error(const length_error&) noexcept;
+    };
+
+    class out_of_range: public logic_error
+    {
+        public:
+            explicit out_of_range(const string&);
+            explicit out_of_range(const char*);
+            out_of_range(const out_of_range&) noexcept;
+    };
+
+    class runtime_error: public exception
+    {
+        public:
+            explicit runtime_error(const string&);
+            explicit runtime_error(const char*);
+            runtime_error(const runtime_error&) noexcept;
+            runtime_error& operator=(const runtime_error&);
+            ~runtime_error() override;
+
+            const char* what() const noexcept override;
+
+        protected:
+            const char* what_;
+    };
+
+    class range_error: public runtime_error
+    {
+        public:
+            explicit range_error(const string&);
+            explicit range_error(const char*);
+            range_error(const range_error&) noexcept;
+    };
+
+    class overflow_error: public runtime_error
+    {
+        public:
+            explicit overflow_error(const string&);
+            explicit overflow_error(const char*);
+            overflow_error(const overflow_error&) noexcept;
+    };
+
+    class underflow_error: public runtime_error
+    {
+        public:
+            explicit underflow_error(const string&);
+            explicit underflow_error(const char*);
+            underflow_error(const underflow_error&) noexcept;
+    };
+}
 
 #endif
Index: uspace/lib/cpp/src/stdexcept.cpp
===================================================================
--- uspace/lib/cpp/src/stdexcept.cpp	(revision 0d221d2827fc28ca8e9907c4bd67482237688824)
+++ uspace/lib/cpp/src/stdexcept.cpp	(revision 0d221d2827fc28ca8e9907c4bd67482237688824)
@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) 2018 Jaroslav Jindrak
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   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
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <cstdlib>
+#include <cstring>
+#include <stdexcept>
+#include <string>
+
+namespace std
+{
+    logic_error::logic_error(const string& what)
+        : what_{hel::str_dup(what.c_str())}
+    { /* DUMMY BODY */ }
+
+    logic_error::logic_error(const char* what)
+        : what_{hel::str_dup(what)}
+    { /* DUMMY BODY */ }
+
+    logic_error::logic_error(const logic_error& other) noexcept
+        : exception{other}, what_{hel::str_dup(other.what_)}
+    { /* DUMMY BODY */ }
+
+    logic_error& logic_error::operator=(const logic_error& other)
+    {
+        if (what_)
+            free(what_);
+        what_ = hel::str_dup(other.what_);
+
+        return *this;
+    }
+
+    logic_error::~logic_error()
+    {
+        free(what_);
+    }
+
+    const char* logic_error::what() const noexcept
+    {
+        return what_;
+    }
+
+    domain_error::domain_error(const string& what)
+        : logic_error{what}
+    { /* DUMMY BODY */ }
+
+    domain_error::domain_error(const char* what)
+        : logic_error{what}
+    { /* DUMMY BODY */ }
+
+    domain_error::domain_error(const domain_error& other) noexcept
+        : logic_error{other}
+    { /* DUMMY BODY */ }
+
+    invalid_argument::invalid_argument(const string& what)
+        : logic_error{what}
+    { /* DUMMY BODY */ }
+
+    invalid_argument::invalid_argument(const char* what)
+        : logic_error{what}
+    { /* DUMMY BODY */ }
+
+    invalid_argument::invalid_argument(const invalid_argument& other) noexcept
+        : logic_error{other}
+    { /* DUMMY BODY */ }
+
+    length_error::length_error(const string& what)
+        : logic_error{what}
+    { /* DUMMY BODY */ }
+
+    length_error::length_error(const char* what)
+        : logic_error{what}
+    { /* DUMMY BODY */ }
+
+    length_error::length_error(const length_error& other) noexcept
+        : logic_error{other}
+    { /* DUMMY BODY */ }
+
+    out_of_range::out_of_range(const string& what)
+        : logic_error{what}
+    { /* DUMMY BODY */ }
+
+    out_of_range::out_of_range(const char* what)
+        : logic_error{what}
+    { /* DUMMY BODY */ }
+
+    out_of_range::out_of_range(const out_of_range& other) noexcept
+        : logic_error{other}
+    { /* DUMMY BODY */ }
+
+    runtime_error::runtime_error(const string& what)
+        : what_{hel::str_dup(what.c_str())}
+    { /* DUMMY BODY */ }
+
+    runtime_error::runtime_error(const char* what)
+        : what_{hel::str_dup(what)}
+    { /* DUMMY BODY */ }
+
+    runtime_error::runtime_error(const runtime_error& other) noexcept
+        : exception{other}, what_{hel::str_dup(other.what_)}
+    { /* DUMMY BODY */ }
+
+    runtime_error& runtime_error::operator=(const runtime_error& other)
+    {
+        if (what_)
+            free(what_);
+        what_ = hel::str_dup(other.what_);
+
+        return *this;
+    }
+
+    runtime_error::~runtime_error()
+    {
+        free(what_);
+    }
+
+    const char* runtime_error::what() const noexcept
+    {
+        return what_;
+    }
+
+    range_error::range_error(const string& what)
+        : runtime_error{what}
+    { /* DUMMY BODY */ }
+
+    range_error::range_error(const char* what)
+        : runtime_error{what}
+    { /* DUMMY BODY */ }
+
+    range_error::range_error(const range_error& other) noexcept
+        : runtime_error{other}
+    { /* DUMMY BODY */ }
+
+    overflow_error::overflow_error(const string& what)
+        : runtime_error{what}
+    { /* DUMMY BODY */ }
+
+    overflow_error::overflow_error(const char* what)
+        : runtime_error{what}
+    { /* DUMMY BODY */ }
+
+    overflow_error::overflow_error(const overflow_error& other) noexcept
+        : runtime_error{other}
+    { /* DUMMY BODY */ }
+
+    underflow_error::underflow_error(const string& what)
+        : runtime_error{what}
+    { /* DUMMY BODY */ }
+
+    underflow_error::underflow_error(const char* what)
+        : runtime_error{what}
+    { /* DUMMY BODY */ }
+
+    underflow_error::underflow_error(const underflow_error& other) noexcept
+        : runtime_error{other}
+    { /* DUMMY BODY */ }
+}