LibCore: Put all classes in the Core namespace and remove the leading C

I've been wanting to do this for a long time. It's time we start being
consistent about how this stuff works.

The new convention is:

- "LibFoo" is a userspace library that provides the "Foo" namespace.

That's it :^) This was pretty tedious to convert and I didn't even
start on LibGUI yet. But it's coming up next.

119 files changed, 1016 insertions, 816 deletions

diff --git a/Libraries/LibAudio/AWavLoader.cpp b/Libraries/LibAudio/AWavLoader.cpp
index 424a17b135..0bfc36d6c5 100644
--- a/Libraries/LibAudio/AWavLoader.cpp
+++ b/Libraries/LibAudio/AWavLoader.cpp
@@ -31,9 +31,9 @@
 #include <limits>
 
 AWavLoader::AWavLoader(const StringView& path)
-    : m_file(CFile::construct(path))
+    : m_file(Core::File::construct(path))
 {
-    if (!m_file->open(CIODevice::ReadOnly)) {
+    if (!m_file->open(Core::IODevice::ReadOnly)) {
         m_error_string = String::format("Can't open file: %s", m_file->error_string());
         return;
     }
@@ -75,7 +75,7 @@ void AWavLoader::reset()
 
 bool AWavLoader::parse_header()
 {
-    CIODeviceStreamReader stream(*m_file);
+    Core::IODeviceStreamReader stream(*m_file);
 
 #define CHECK_OK(msg)                                                           \
     do {                                                                        \
diff --git a/Libraries/LibAudio/AWavLoader.h b/Libraries/LibAudio/AWavLoader.h
index 980823d502..8b6b553879 100644
--- a/Libraries/LibAudio/AWavLoader.h
+++ b/Libraries/LibAudio/AWavLoader.h
@@ -56,11 +56,11 @@ public:
     u32 sample_rate() const { return m_sample_rate; }
     u16 num_channels() const { return m_num_channels; }
     u16 bits_per_sample() const { return m_bits_per_sample; }
-    RefPtr<CFile> file() const { return m_file; }
+    RefPtr<Core::File> file() const { return m_file; }
 
 private:
     bool parse_header();
-    RefPtr<CFile> m_file;
+    RefPtr<Core::File> m_file;
     String m_error_string;
     OwnPtr<AResampleHelper> m_resampler;
 
diff --git a/Libraries/LibCore/CArgsParser.cpp b/Libraries/LibCore/CArgsParser.cpp
index 4db160ed9d..e73bfb4f63 100644
--- a/Libraries/LibCore/CArgsParser.cpp
+++ b/Libraries/LibCore/CArgsParser.cpp
@@ -30,12 +30,14 @@
 #include <limits.h>
 #include <stdio.h>
 
-CArgsParser::CArgsParser()
+namespace Core {
+
+ArgsParser::ArgsParser()
 {
     add_option(m_show_help, "Display this message", "help", 0);
 }
 
-void CArgsParser::parse(int argc, char** argv)
+void ArgsParser::parse(int argc, char** argv)
 {
     auto print_usage_and_exit = [this, argv] {
         print_usage(stderr, argv[0]);
@@ -148,7 +150,7 @@ void CArgsParser::parse(int argc, char** argv)
     }
 }
 
-void CArgsParser::print_usage(FILE* file, const char* argv0)
+void ArgsParser::print_usage(FILE* file, const char* argv0)
 {
     fprintf(file, "Usage:\n\t%s", argv0);
 
@@ -214,12 +216,12 @@ void CArgsParser::print_usage(FILE* file, const char* argv0)
     }
 }
 
-void CArgsParser::add_option(Option&& option)
+void ArgsParser::add_option(Option&& option)
 {
     m_options.append(move(option));
 }
 
-void CArgsParser::add_option(bool& value, const char* help_string, const char* long_name, char short_name)
+void ArgsParser::add_option(bool& value, const char* help_string, const char* long_name, char short_name)
 {
     Option option {
         false,
@@ -236,7 +238,7 @@ void CArgsParser::add_option(bool& value, const char* help_string, const char* l
     add_option(move(option));
 }
 
-void CArgsParser::add_option(const char*& value, const char* help_string, const char* long_name, char short_name, const char* value_name)
+void ArgsParser::add_option(const char*& value, const char* help_string, const char* long_name, char short_name, const char* value_name)
 {
     Option option {
         true,
@@ -252,7 +254,7 @@ void CArgsParser::add_option(const char*& value, const char* help_string, const
     add_option(move(option));
 }
 
-void CArgsParser::add_option(int& value, const char* help_string, const char* long_name, char short_name, const char* value_name)
+void ArgsParser::add_option(int& value, const char* help_string, const char* long_name, char short_name, const char* value_name)
 {
     Option option {
         true,
@@ -269,12 +271,12 @@ void CArgsParser::add_option(int& value, const char* help_string, const char* lo
     add_option(move(option));
 }
 
-void CArgsParser::add_positional_argument(Arg&& arg)
+void ArgsParser::add_positional_argument(Arg&& arg)
 {
     m_positional_args.append(move(arg));
 }
 
-void CArgsParser::add_positional_argument(const char*& value, const char* help_string, const char* name, Required required)
+void ArgsParser::add_positional_argument(const char*& value, const char* help_string, const char* name, Required required)
 {
     Arg arg {
         help_string,
@@ -289,7 +291,7 @@ void CArgsParser::add_positional_argument(const char*& value, const char* help_s
     add_positional_argument(move(arg));
 }
 
-void CArgsParser::add_positional_argument(int& value, const char* help_string, const char* name, Required required)
+void ArgsParser::add_positional_argument(int& value, const char* help_string, const char* name, Required required)
 {
     Arg arg {
         help_string,
@@ -305,7 +307,7 @@ void CArgsParser::add_positional_argument(int& value, const char* help_string, c
     add_positional_argument(move(arg));
 }
 
-void CArgsParser::add_positional_argument(Vector<const char*>& values, const char* help_string, const char* name, Required required)
+void ArgsParser::add_positional_argument(Vector<const char*>& values, const char* help_string, const char* name, Required required)
 {
     Arg arg {
         help_string,
@@ -319,3 +321,5 @@ void CArgsParser::add_positional_argument(Vector<const char*>& values, const cha
     };
     add_positional_argument(move(arg));
 }
+
+}
diff --git a/Libraries/LibCore/CArgsParser.h b/Libraries/LibCore/CArgsParser.h
index 70adfacc16..69520e7002 100644
--- a/Libraries/LibCore/CArgsParser.h
+++ b/Libraries/LibCore/CArgsParser.h
@@ -31,9 +31,11 @@
 #include <AK/Vector.h>
 #include <stdio.h>
 
-class CArgsParser {
+namespace Core {
+
+class ArgsParser {
 public:
-    CArgsParser();
+    ArgsParser();
 
     enum class Required {
         Yes,
@@ -83,3 +85,5 @@ private:
 
     bool m_show_help { false };
 };
+
+}
diff --git a/Libraries/LibCore/CConfigFile.cpp b/Libraries/LibCore/CConfigFile.cpp
index 0bce975aac..c5a463efed 100644
--- a/Libraries/LibCore/CConfigFile.cpp
+++ b/Libraries/LibCore/CConfigFile.cpp
@@ -32,43 +32,45 @@
 #include <stdio.h>
 #include <unistd.h>
 
-NonnullRefPtr<CConfigFile> CConfigFile::get_for_app(const String& app_name)
+namespace Core {
+
+NonnullRefPtr<ConfigFile> ConfigFile::get_for_app(const String& app_name)
 {
     String home_path = get_current_user_home_path();
     if (home_path == "/")
         home_path = String::format("/tmp");
     auto path = String::format("%s/%s.ini", home_path.characters(), app_name.characters());
-    return adopt(*new CConfigFile(path));
+    return adopt(*new ConfigFile(path));
 }
 
-NonnullRefPtr<CConfigFile> CConfigFile::get_for_system(const String& app_name)
+NonnullRefPtr<ConfigFile> ConfigFile::get_for_system(const String& app_name)
 {
     auto path = String::format("/etc/%s.ini", app_name.characters());
-    return adopt(*new CConfigFile(path));
+    return adopt(*new ConfigFile(path));
 }
 
-NonnullRefPtr<CConfigFile> CConfigFile::open(const String& path)
+NonnullRefPtr<ConfigFile> ConfigFile::open(const String& path)
 {
-    return adopt(*new CConfigFile(path));
+    return adopt(*new ConfigFile(path));
 }
 
-CConfigFile::CConfigFile(const String& file_name)
+ConfigFile::ConfigFile(const String& file_name)
     : m_file_name(file_name)
 {
     reparse();
 }
 
-CConfigFile::~CConfigFile()
+ConfigFile::~ConfigFile()
 {
     sync();
 }
 
-void CConfigFile::reparse()
+void ConfigFile::reparse()
 {
     m_groups.clear();
 
-    auto file = CFile::construct(m_file_name);
-    if (!file->open(CIODevice::OpenMode::ReadOnly))
+    auto file = File::construct(m_file_name);
+    if (!file->open(IODevice::OpenMode::ReadOnly))
         return;
 
     HashMap<String, String>* current_group = nullptr;
@@ -111,10 +113,10 @@ void CConfigFile::reparse()
     }
 }
 
-String CConfigFile::read_entry(const String& group, const String& key, const String& default_value) const
+String ConfigFile::read_entry(const String& group, const String& key, const String& default_value) const
 {
     if (!has_key(group, key)) {
-        const_cast<CConfigFile&>(*this).write_entry(group, key, default_value);
+        const_cast<ConfigFile&>(*this).write_entry(group, key, default_value);
         return default_value;
     }
     auto it = m_groups.find(group);
@@ -122,10 +124,10 @@ String CConfigFile::read_entry(const String& group, const String& key, const Str
     return jt->value;
 }
 
-int CConfigFile::read_num_entry(const String& group, const String& key, int default_value) const
+int ConfigFile::read_num_entry(const String& group, const String& key, int default_value) const
 {
     if (!has_key(group, key)) {
-        const_cast<CConfigFile&>(*this).write_num_entry(group, key, default_value);
+        const_cast<ConfigFile&>(*this).write_num_entry(group, key, default_value);
         return default_value;
     }
 
@@ -136,31 +138,31 @@ int CConfigFile::read_num_entry(const String& group, const String& key, int defa
     return value;
 }
 
-bool CConfigFile::read_bool_entry(const String& group, const String& key, bool default_value) const
+bool ConfigFile::read_bool_entry(const String& group, const String& key, bool default_value) const
 {
     return read_entry(group, key, default_value ? "1" : "0") == "1";
 }
 
-void CConfigFile::write_entry(const String& group, const String& key, const String& value)
+void ConfigFile::write_entry(const String& group, const String& key, const String& value)
 {
     m_groups.ensure(group).ensure(key) = value;
     m_dirty = true;
 }
 
-void CConfigFile::write_num_entry(const String& group, const String& key, int value)
+void ConfigFile::write_num_entry(const String& group, const String& key, int value)
 {
     write_entry(group, key, String::number(value));
 }
-void CConfigFile::write_bool_entry(const String& group, const String& key, bool value)
+void ConfigFile::write_bool_entry(const String& group, const String& key, bool value)
 {
     write_entry(group, key, value ? "1" : "0");
 }
-void CConfigFile::write_color_entry(const String& group, const String& key, Color value)
+void ConfigFile::write_color_entry(const String& group, const String& key, Color value)
 {
     write_entry(group, key, String::format("%d,%d,%d,%d", value.red(), value.green(), value.blue(), value.alpha()));
 }
 
-bool CConfigFile::sync()
+bool ConfigFile::sync()
 {
     if (!m_dirty)
         return true;
@@ -182,7 +184,7 @@ bool CConfigFile::sync()
     return true;
 }
 
-void CConfigFile::dump() const
+void ConfigFile::dump() const
 {
     for (auto& it : m_groups) {
         printf("[%s]\n", it.key.characters());
@@ -192,12 +194,12 @@ void CConfigFile::dump() const
     }
 }
 
-Vector<String> CConfigFile::groups() const
+Vector<String> ConfigFile::groups() const
 {
     return m_groups.keys();
 }
 
-Vector<String> CConfigFile::keys(const String& group) const
+Vector<String> ConfigFile::keys(const String& group) const
 {
     auto it = m_groups.find(group);
     if (it == m_groups.end())
@@ -205,7 +207,7 @@ Vector<String> CConfigFile::keys(const String& group) const
     return it->value.keys();
 }
 
-bool CConfigFile::has_key(const String& group, const String& key) const
+bool ConfigFile::has_key(const String& group, const String& key) const
 {
     auto it = m_groups.find(group);
     if (it == m_groups.end())
@@ -213,18 +215,18 @@ bool CConfigFile::has_key(const String& group, const String& key) const
     return it->value.contains(key);
 }
 
-bool CConfigFile::has_group(const String& group) const
+bool ConfigFile::has_group(const String& group) const
 {
     return m_groups.contains(group);
 }
 
-void CConfigFile::remove_group(const String& group)
+void ConfigFile::remove_group(const String& group)
 {
     m_groups.remove(group);
     m_dirty = true;
 }
 
-void CConfigFile::remove_entry(const String& group, const String& key)
+void ConfigFile::remove_entry(const String& group, const String& key)
 {
     auto it = m_groups.find(group);
     if (it == m_groups.end())
@@ -232,3 +234,5 @@ void CConfigFile::remove_entry(const String& group, const String& key)
     it->value.remove(key);
     m_dirty = true;
 }
+
+}
diff --git a/Libraries/LibCore/CConfigFile.h b/Libraries/LibCore/CConfigFile.h
index 88650864d9..15ff959b6f 100644
--- a/Libraries/LibCore/CConfigFile.h
+++ b/Libraries/LibCore/CConfigFile.h
@@ -26,19 +26,21 @@
 
 #pragma once
 
-#include <AK/String.h>
 #include <AK/HashMap.h>
-#include <AK/RefPtr.h>
 #include <AK/RefCounted.h>
+#include <AK/RefPtr.h>
+#include <AK/String.h>
 #include <AK/Vector.h>
 #include <LibDraw/Color.h>
 
-class CConfigFile : public RefCounted<CConfigFile> {
+namespace Core {
+
+class ConfigFile : public RefCounted<ConfigFile> {
 public:
-    static NonnullRefPtr<CConfigFile> get_for_app(const String& app_name);
-    static NonnullRefPtr<CConfigFile> get_for_system(const String& app_name);
-    static NonnullRefPtr<CConfigFile> open(const String& path);
-    ~CConfigFile();
+    static NonnullRefPtr<ConfigFile> get_for_app(const String& app_name);
+    static NonnullRefPtr<ConfigFile> get_for_system(const String& app_name);
+    static NonnullRefPtr<ConfigFile> open(const String& path);
+    ~ConfigFile();
 
     bool has_group(const String&) const;
     bool has_key(const String& group, const String& key) const;
@@ -67,7 +69,7 @@ public:
     String file_name() const { return m_file_name; }
 
 private:
-    explicit CConfigFile(const String& file_name);
+    explicit ConfigFile(const String& file_name);
 
     void reparse();
 
@@ -75,3 +77,5 @@ private:
     HashMap<String, HashMap<String, String>> m_groups;
     bool m_dirty { false };
 };
+
+}
diff --git a/Libraries/LibCore/CDirIterator.cpp b/Libraries/LibCore/CDirIterator.cpp
index 8e5f2cf111..7da1460e50 100644
--- a/Libraries/LibCore/CDirIterator.cpp
+++ b/Libraries/LibCore/CDirIterator.cpp
@@ -25,9 +25,11 @@
  */
 
 #include "CDirIterator.h"
-#include <cerrno>
+#include <errno.h>
 
-CDirIterator::CDirIterator(const StringView& path, Flags flags)
+namespace Core {
+
+DirIterator::DirIterator(const StringView& path, Flags flags)
     : m_flags(flags)
 {
     m_dir = opendir(String(path).characters());
@@ -36,7 +38,7 @@ CDirIterator::CDirIterator(const StringView& path, Flags flags)
     }
 }
 
-CDirIterator::~CDirIterator()
+DirIterator::~DirIterator()
 {
     if (m_dir != nullptr) {
         closedir(m_dir);
@@ -44,7 +46,7 @@ CDirIterator::~CDirIterator()
     }
 }
 
-bool CDirIterator::advance_next()
+bool DirIterator::advance_next()
 {
     if (m_dir == nullptr)
         return false;
@@ -74,7 +76,7 @@ bool CDirIterator::advance_next()
     return m_next.length() > 0;
 }
 
-bool CDirIterator::has_next()
+bool DirIterator::has_next()
 {
     if (!m_next.is_null())
         return true;
@@ -82,7 +84,7 @@ bool CDirIterator::has_next()
     return advance_next();
 }
 
-String CDirIterator::next_path()
+String DirIterator::next_path()
 {
     if (m_next.is_null())
         advance_next();
@@ -91,3 +93,5 @@ String CDirIterator::next_path()
     m_next = String();
     return tmp;
 }
+
+}
diff --git a/Libraries/LibCore/CDirIterator.h b/Libraries/LibCore/CDirIterator.h
index ef19f46866..a7aa80f5c6 100644
--- a/Libraries/LibCore/CDirIterator.h
+++ b/Libraries/LibCore/CDirIterator.h
@@ -29,15 +29,17 @@
 #include <AK/String.h>
 #include <dirent.h>
 
-class CDirIterator {
+namespace Core {
+
+class DirIterator {
 public:
     enum Flags {
         NoFlags = 0x0,
         SkipDots = 0x1,
     };
 
-    CDirIterator(const StringView& path, Flags = Flags::NoFlags);
-    ~CDirIterator();
+    DirIterator(const StringView& path, Flags = Flags::NoFlags);
+    ~DirIterator();
 
     bool has_error() const { return m_error != 0; }
     int error() const { return m_error; }
@@ -53,3 +55,5 @@ private:
 
     bool advance_next();
 };
+
+}
diff --git a/Libraries/LibCore/CElapsedTimer.cpp b/Libraries/LibCore/CElapsedTimer.cpp
index a271b709e2..8d16722297 100644
--- a/Libraries/LibCore/CElapsedTimer.cpp
+++ b/Libraries/LibCore/CElapsedTimer.cpp
@@ -29,13 +29,15 @@
 #include <LibCore/CElapsedTimer.h>
 #include <sys/time.h>
 
-void CElapsedTimer::start()
+namespace Core {
+
+void ElapsedTimer::start()
 {
     m_valid = true;
     gettimeofday(&m_start_time, nullptr);
 }
 
-int CElapsedTimer::elapsed() const
+int ElapsedTimer::elapsed() const
 {
     ASSERT(is_valid());
     struct timeval now;
@@ -44,3 +46,5 @@ int CElapsedTimer::elapsed() const
     timeval_sub(now, m_start_time, diff);
     return diff.tv_sec * 1000 + diff.tv_usec / 1000;
 }
+
+}
diff --git a/Libraries/LibCore/CElapsedTimer.h b/Libraries/LibCore/CElapsedTimer.h
index 2c9718fd5d..7db9ff0bb7 100644
--- a/Libraries/LibCore/CElapsedTimer.h
+++ b/Libraries/LibCore/CElapsedTimer.h
@@ -28,9 +28,11 @@
 
 #include <sys/time.h>
 
-class CElapsedTimer {
+namespace Core {
+
+class ElapsedTimer {
 public:
-    CElapsedTimer() {}
+    ElapsedTimer() {}
 
     bool is_valid() const { return m_valid; }
     void start();
@@ -42,3 +44,5 @@ private:
         0, 0
     };
 };
+
+}
diff --git a/Libraries/LibCore/CEvent.cpp b/Libraries/LibCore/CEvent.cpp
index cd36fd3e07..99d752d264 100644
--- a/Libraries/LibCore/CEvent.cpp
+++ b/Libraries/LibCore/CEvent.cpp
@@ -27,13 +27,17 @@
 #include <LibCore/CEvent.h>
 #include <LibCore/CObject.h>
 
-CChildEvent::CChildEvent(Type type, CObject& child, CObject* insertion_before_child)
-    : CEvent(type)
+namespace Core {
+
+ChildEvent::ChildEvent(Type type, Object& child, Object* insertion_before_child)
+    : Core::Event(type)
     , m_child(child.make_weak_ptr())
     , m_insertion_before_child(insertion_before_child ? insertion_before_child->make_weak_ptr() : nullptr)
 {
 }
 
-CChildEvent::~CChildEvent()
+ChildEvent::~ChildEvent()
 {
 }
+
+}
diff --git a/Libraries/LibCore/CEvent.h b/Libraries/LibCore/CEvent.h
index 169b8cc7cc..d3c7cc1f22 100644
--- a/Libraries/LibCore/CEvent.h
+++ b/Libraries/LibCore/CEvent.h
@@ -26,14 +26,16 @@
 
 #pragma once
 
-#include <AK/String.h>
 #include <AK/Function.h>
+#include <AK/String.h>
 #include <AK/Types.h>
 #include <AK/WeakPtr.h>
 
-class CObject;
+namespace Core {
 
-class CEvent {
+class Object;
+
+class Event {
 public:
     enum Type {
         Invalid = 0,
@@ -47,12 +49,12 @@ public:
         Custom,
     };
 
-    CEvent() {}
-    explicit CEvent(unsigned type)
+    Event() {}
+    explicit Event(unsigned type)
         : m_type(type)
     {
     }
-    virtual ~CEvent() {}
+    virtual ~Event() {}
 
     unsigned type() const { return m_type; }
 
@@ -65,28 +67,28 @@ private:
     bool m_accepted { true };
 };
 
-class CDeferredInvocationEvent : public CEvent {
-    friend class CEventLoop;
+class DeferredInvocationEvent : public Event {
+    friend class EventLoop;
 
 public:
-    CDeferredInvocationEvent(Function<void(CObject&)> invokee)
-        : CEvent(CEvent::Type::DeferredInvoke)
+    DeferredInvocationEvent(Function<void(Object&)> invokee)
+        : Event(Event::Type::DeferredInvoke)
         , m_invokee(move(invokee))
     {
     }
 
 private:
-    Function<void(CObject&)> m_invokee;
+    Function<void(Object&)> m_invokee;
 };
 
-class CTimerEvent final : public CEvent {
+class TimerEvent final : public Event {
 public:
-    explicit CTimerEvent(int timer_id)
-        : CEvent(CEvent::Timer)
+    explicit TimerEvent(int timer_id)
+        : Event(Event::Timer)
         , m_timer_id(timer_id)
     {
     }
-    ~CTimerEvent() {}
+    ~TimerEvent() {}
 
     int timer_id() const { return m_timer_id; }
 
@@ -94,14 +96,14 @@ private:
     int m_timer_id;
 };
 
-class CNotifierReadEvent final : public CEvent {
+class NotifierReadEvent final : public Event {
 public:
-    explicit CNotifierReadEvent(int fd)
-        : CEvent(CEvent::NotifierRead)
+    explicit NotifierReadEvent(int fd)
+        : Event(Event::NotifierRead)
         , m_fd(fd)
     {
     }
-    ~CNotifierReadEvent() {}
+    ~NotifierReadEvent() {}
 
     int fd() const { return m_fd; }
 
@@ -109,14 +111,14 @@ private:
     int m_fd;
 };
 
-class CNotifierWriteEvent final : public CEvent {
+class NotifierWriteEvent final : public Event {
 public:
-    explicit CNotifierWriteEvent(int fd)
-        : CEvent(CEvent::NotifierWrite)
+    explicit NotifierWriteEvent(int fd)
+        : Event(Event::NotifierWrite)
         , m_fd(fd)
     {
     }
-    ~CNotifierWriteEvent() {}
+    ~NotifierWriteEvent() {}
 
     int fd() const { return m_fd; }
 
@@ -124,31 +126,31 @@ private:
     int m_fd;
 };
 
-class CChildEvent final : public CEvent {
+class ChildEvent final : public Event {
 public:
-    CChildEvent(Type, CObject& child, CObject* insertion_before_child = nullptr);
-    ~CChildEvent();
+    ChildEvent(Type, Object& child, Object* insertion_before_child = nullptr);
+    ~ChildEvent();
 
-    CObject* child() { return m_child.ptr(); }
-    const CObject* child() const { return m_child.ptr(); }
+    Object* child() { return m_child.ptr(); }
+    const Object* child() const { return m_child.ptr(); }
 
-    CObject* insertion_before_child() { return m_insertion_before_child.ptr(); }
-    const CObject* insertion_before_child() const { return m_insertion_before_child.ptr(); }
+    Object* insertion_before_child() { return m_insertion_before_child.ptr(); }
+    const Object* insertion_before_child() const { return m_insertion_before_child.ptr(); }
 
 private:
-    WeakPtr<CObject> m_child;
-    WeakPtr<CObject> m_insertion_before_child;
+    WeakPtr<Object> m_child;
+    WeakPtr<Object> m_insertion_before_child;
 };
 
-class CCustomEvent : public CEvent {
+class CustomEvent : public Event {
 public:
-    CCustomEvent(int custom_type, void* data = nullptr)
-        : CEvent(CEvent::Type::Custom)
+    CustomEvent(int custom_type, void* data = nullptr)
+        : Event(Event::Type::Custom)
         , m_custom_type(custom_type)
         , m_data(data)
     {
     }
-    ~CCustomEvent() {}
+    ~CustomEvent() {}
 
     int custom_type() const { return m_custom_type; }
     void* data() { return m_data; }
@@ -158,3 +160,5 @@ private:
     int m_custom_type { 0 };
     void* m_data { nullptr };
 };
+
+}
diff --git a/Libraries/LibCore/CEventLoop.cpp b/Libraries/LibCore/CEventLoop.cpp
index 857f43ad20..60f87cfc3e 100644
--- a/Libraries/LibCore/CEventLoop.cpp
+++ b/Libraries/LibCore/CEventLoop.cpp
@@ -49,21 +49,23 @@
 //#define CEVENTLOOP_DEBUG
 //#define DEFERRED_INVOKE_DEBUG
 
+namespace Core {
+
 class RPCClient;
 
-static CEventLoop* s_main_event_loop;
-static Vector<CEventLoop*>* s_event_loop_stack;
+static EventLoop* s_main_event_loop;
+static Vector<EventLoop*>* s_event_loop_stack;
 static IDAllocator s_id_allocator;
-HashMap<int, NonnullOwnPtr<CEventLoop::EventLoopTimer>>* CEventLoop::s_timers;
-HashTable<CNotifier*>* CEventLoop::s_notifiers;
-int CEventLoop::s_wake_pipe_fds[2];
-RefPtr<CLocalServer> CEventLoop::s_rpc_server;
+HashMap<int, NonnullOwnPtr<EventLoop::EventLoopTimer>>* EventLoop::s_timers;
+HashTable<Notifier*>* EventLoop::s_notifiers;
+int EventLoop::s_wake_pipe_fds[2];
+RefPtr<LocalServer> EventLoop::s_rpc_server;
 HashMap<int, RefPtr<RPCClient>> s_rpc_clients;
 
-class RPCClient : public CObject {
+class RPCClient : public Object {
     C_OBJECT(RPCClient)
 public:
-    explicit RPCClient(RefPtr<CLocalSocket> socket)
+    explicit RPCClient(RefPtr<LocalSocket> socket)
         : m_socket(move(socket))
         , m_client_id(s_id_allocator.allocate())
     {
@@ -131,7 +133,7 @@ public:
             JsonObject response;
             response.set("type", type);
             JsonArray objects;
-            for (auto& object : CObject::all_objects()) {
+            for (auto& object : Object::all_objects()) {
                 JsonObject json_object;
                 object.save_to(json_object);
                 objects.append(move(json_object));
@@ -154,16 +156,16 @@ public:
     }
 
 private:
-    RefPtr<CLocalSocket> m_socket;
+    RefPtr<LocalSocket> m_socket;
     int m_client_id { -1 };
 };
 
-CEventLoop::CEventLoop()
+EventLoop::EventLoop()
 {
     if (!s_event_loop_stack) {
-        s_event_loop_stack = new Vector<CEventLoop*>;
-        s_timers = new HashMap<int, NonnullOwnPtr<CEventLoop::EventLoopTimer>>;
-        s_notifiers = new HashTable<CNotifier*>;
+        s_event_loop_stack = new Vector<EventLoop*>;
+        s_timers = new HashMap<int, NonnullOwnPtr<EventLoop::EventLoopTimer>>;
+        s_notifiers = new HashTable<Notifier*>;
     }
 
     if (!s_main_event_loop) {
@@ -185,8 +187,8 @@ CEventLoop::CEventLoop()
             perror("unlink");
             ASSERT_NOT_REACHED();
         }
-        s_rpc_server = CLocalServer::construct();
-        s_rpc_server->set_name("CEventLoop_RPC_server");
+        s_rpc_server = LocalServer::construct();
+        s_rpc_server->set_name("Core::EventLoop_RPC_server");
         bool listening = s_rpc_server->listen(rpc_path);
         ASSERT(listening);
 
@@ -196,66 +198,66 @@ CEventLoop::CEventLoop()
     }
 
 #ifdef CEVENTLOOP_DEBUG
-    dbg() << getpid() << " CEventLoop constructed :)";
+    dbg() << getpid() << " Core::EventLoop constructed :)";
 #endif
 }
 
-CEventLoop::~CEventLoop()
+EventLoop::~EventLoop()
 {
 }
 
-CEventLoop& CEventLoop::main()
+EventLoop& EventLoop::main()
 {
     ASSERT(s_main_event_loop);
     return *s_main_event_loop;
 }
 
-CEventLoop& CEventLoop::current()
+EventLoop& EventLoop::current()
 {
-    CEventLoop* event_loop = s_event_loop_stack->last();
+    EventLoop* event_loop = s_event_loop_stack->last();
     ASSERT(event_loop != nullptr);
     return *event_loop;
 }
 
-void CEventLoop::quit(int code)
+void EventLoop::quit(int code)
 {
-    dbg() << "CEventLoop::quit(" << code << ")";
+    dbg() << "Core::EventLoop::quit(" << code << ")";
     m_exit_requested = true;
     m_exit_code = code;
 }
 
-void CEventLoop::unquit()
+void EventLoop::unquit()
 {
-    dbg() << "CEventLoop::unquit()";
+    dbg() << "Core::EventLoop::unquit()";
     m_exit_requested = false;
     m_exit_code = 0;
 }
 
-struct CEventLoopPusher {
+struct EventLoopPusher {
 public:
-    CEventLoopPusher(CEventLoop& event_loop)
+    EventLoopPusher(EventLoop& event_loop)
         : m_event_loop(event_loop)
     {
         if (&m_event_loop != s_main_event_loop) {
-            m_event_loop.take_pending_events_from(CEventLoop::current());
+            m_event_loop.take_pending_events_from(EventLoop::current());
             s_event_loop_stack->append(&event_loop);
         }
     }
-    ~CEventLoopPusher()
+    ~EventLoopPusher()
     {
         if (&m_event_loop != s_main_event_loop) {
             s_event_loop_stack->take_last();
-            CEventLoop::current().take_pending_events_from(m_event_loop);
+            EventLoop::current().take_pending_events_from(m_event_loop);
         }
     }
 
 private:
-    CEventLoop& m_event_loop;
+    EventLoop& m_event_loop;
 };
 
-int CEventLoop::exec()
+int EventLoop::exec()
 {
-    CEventLoopPusher pusher(*this);
+    EventLoopPusher pusher(*this);
     for (;;) {
         if (m_exit_requested)
             return m_exit_code;
@@ -264,7 +266,7 @@ int CEventLoop::exec()
     ASSERT_NOT_REACHED();
 }
 
-void CEventLoop::pump(WaitMode mode)
+void EventLoop::pump(WaitMode mode)
 {
     if (m_queued_events.is_empty())
         wait_for_event(mode);
@@ -284,30 +286,30 @@ void CEventLoop::pump(WaitMode mode)
         auto& event = *queued_event.event;
 #ifdef CEVENTLOOP_DEBUG
         if (receiver)
-            dbg() << "CEventLoop: " << *receiver << " event " << (int)event.type();
+            dbg() << "Core::EventLoop: " << *receiver << " event " << (int)event.type();
 #endif
         if (!receiver) {
             switch (event.type()) {
-            case CEvent::Quit:
+            case Event::Quit:
                 ASSERT_NOT_REACHED();
                 return;
             default:
                 dbg() << "Event type " << event.type() << " with no receiver :(";
             }
-        } else if (event.type() == CEvent::Type::DeferredInvoke) {
+        } else if (event.type() == Event::Type::DeferredInvoke) {
 #ifdef DEFERRED_INVOKE_DEBUG
             printf("DeferredInvoke: receiver=%s{%p}\n", receiver->class_name(), receiver);
 #endif
-            static_cast<CDeferredInvocationEvent&>(event).m_invokee(*receiver);
+            static_cast<DeferredInvocationEvent&>(event).m_invokee(*receiver);
         } else {
-            NonnullRefPtr<CObject> protector(*receiver);
+            NonnullRefPtr<Object> protector(*receiver);
             receiver->dispatch_event(event);
         }
 
         if (m_exit_requested) {
             LOCKER(m_lock);
 #ifdef CEVENTLOOP_DEBUG
-            dbg() << "CEventLoop: Exit requested. Rejigging " << (events.size() - i) << " events.";
+            dbg() << "Core::EventLoop: Exit requested. Rejigging " << (events.size() - i) << " events.";
 #endif
             decltype(m_queued_events) new_event_queue;
             new_event_queue.ensure_capacity(m_queued_events.size() + events.size());
@@ -320,16 +322,16 @@ void CEventLoop::pump(WaitMode mode)
     }
 }
 
-void CEventLoop::post_event(CObject& receiver, NonnullOwnPtr<CEvent>&& event)
+void EventLoop::post_event(Object& receiver, NonnullOwnPtr<Event>&& event)
 {
     LOCKER(m_lock);
 #ifdef CEVENTLOOP_DEBUG
-    dbg() << "CEventLoop::post_event: {" << m_queued_events.size() << "} << receiver=" << receiver << ", event=" << event;
+    dbg() << "Core::EventLoop::post_event: {" << m_queued_events.size() << "} << receiver=" << receiver << ", event=" << event;
 #endif
     m_queued_events.append({ receiver.make_weak_ptr(), move(event) });
 }
 
-void CEventLoop::wait_for_event(WaitMode mode)
+void EventLoop::wait_for_event(WaitMode mode)
 {
     fd_set rfds;
     fd_set wfds;
@@ -347,11 +349,11 @@ void CEventLoop::wait_for_event(WaitMode mode)
     add_fd_to_set(s_wake_pipe_fds[0], rfds);
     max_fd = max(max_fd, max_fd_added);
     for (auto& notifier : *s_notifiers) {
-        if (notifier->event_mask() & CNotifier::Read)
+        if (notifier->event_mask() & Notifier::Read)
             add_fd_to_set(notifier->fd(), rfds);
-        if (notifier->event_mask() & CNotifier::Write)
+        if (notifier->event_mask() & Notifier::Write)
             add_fd_to_set(notifier->fd(), wfds);
-        if (notifier->event_mask() & CNotifier::Exceptional)
+        if (notifier->event_mask() & Notifier::Exceptional)
             ASSERT_NOT_REACHED();
     }
 
@@ -401,9 +403,9 @@ void CEventLoop::wait_for_event(WaitMode mode)
             continue;
         }
 #ifdef CEVENTLOOP_DEBUG
-        dbg() << "CEventLoop: Timer " << timer.timer_id << " has expired, sending CTimerEvent to " << timer.owner;
+        dbg() << "Core::EventLoop: Timer " << timer.timer_id << " has expired, sending Core::TimerEvent to " << timer.owner;
 #endif
-        post_event(*timer.owner, make<CTimerEvent>(timer.timer_id));
+        post_event(*timer.owner, make<TimerEvent>(timer.timer_id));
         if (timer.should_reload) {
             timer.reload(now);
         } else {
@@ -418,28 +420,28 @@ void CEventLoop::wait_for_event(WaitMode mode)
     for (auto& notifier : *s_notifiers) {
         if (FD_ISSET(notifier->fd(), &rfds)) {
             if (notifier->on_ready_to_read)
-                post_event(*notifier, make<CNotifierReadEvent>(notifier->fd()));
+                post_event(*notifier, make<NotifierReadEvent>(notifier->fd()));
         }
         if (FD_ISSET(notifier->fd(), &wfds)) {
             if (notifier->on_ready_to_write)
-                post_event(*notifier, make<CNotifierWriteEvent>(notifier->fd()));
+                post_event(*notifier, make<NotifierWriteEvent>(notifier->fd()));
         }
     }
 }
 
-bool CEventLoop::EventLoopTimer::has_expired(const timeval& now) const
+bool EventLoop::EventLoopTimer::has_expired(const timeval& now) const
 {
     return now.tv_sec > fire_time.tv_sec || (now.tv_sec == fire_time.tv_sec && now.tv_usec >= fire_time.tv_usec);
 }
 
-void CEventLoop::EventLoopTimer::reload(const timeval& now)
+void EventLoop::EventLoopTimer::reload(const timeval& now)
 {
     fire_time = now;
     fire_time.tv_sec += interval / 1000;
     fire_time.tv_usec += (interval % 1000) * 1000;
 }
 
-void CEventLoop::get_next_timer_expiration(timeval& soonest)
+void EventLoop::get_next_timer_expiration(timeval& soonest)
 {
     ASSERT(!s_timers->is_empty());
     bool has_checked_any = false;
@@ -456,7 +458,7 @@ void CEventLoop::get_next_timer_expiration(timeval& soonest)
     }
 }
 
-int CEventLoop::register_timer(CObject& object, int milliseconds, bool should_reload, TimerShouldFireWhenNotVisible fire_when_not_visible)
+int EventLoop::register_timer(Object& object, int milliseconds, bool should_reload, TimerShouldFireWhenNotVisible fire_when_not_visible)
 {
     ASSERT(milliseconds >= 0);
     auto timer = make<EventLoopTimer>();
@@ -473,7 +475,7 @@ int CEventLoop::register_timer(CObject& object, int milliseconds, bool should_re
     return timer_id;
 }
 
-bool CEventLoop::unregister_timer(int timer_id)
+bool EventLoop::unregister_timer(int timer_id)
 {
     s_id_allocator.deallocate(timer_id);
     auto it = s_timers->find(timer_id);
@@ -483,22 +485,24 @@ bool CEventLoop::unregister_timer(int timer_id)
     return true;
 }
 
-void CEventLoop::register_notifier(Badge<CNotifier>, CNotifier& notifier)
+void EventLoop::register_notifier(Badge<Notifier>, Notifier& notifier)
 {
     s_notifiers->set(&notifier);
 }
 
-void CEventLoop::unregister_notifier(Badge<CNotifier>, CNotifier& notifier)
+void EventLoop::unregister_notifier(Badge<Notifier>, Notifier& notifier)
 {
     s_notifiers->remove(&notifier);
 }
 
-void CEventLoop::wake()
+void EventLoop::wake()
 {
     char ch = '!';
     int nwritten = write(s_wake_pipe_fds[1], &ch, 1);
     if (nwritten < 0) {
-        perror("CEventLoop::wake: write");
+        perror("EventLoop::wake: write");
         ASSERT_NOT_REACHED();
     }
 }
+
+}
diff --git a/Libraries/LibCore/CEventLoop.h b/Libraries/LibCore/CEventLoop.h
index 9764563c8d..6c181b051d 100644
--- a/Libraries/LibCore/CEventLoop.h
+++ b/Libraries/LibCore/CEventLoop.h
@@ -38,13 +38,15 @@
 #include <sys/time.h>
 #include <time.h>
 
-class CObject;
-class CNotifier;
+namespace Core {
 
-class CEventLoop {
+class Object;
+class Notifier;
+
+class EventLoop {
 public:
-    CEventLoop();
-    ~CEventLoop();
+    EventLoop();
+    ~EventLoop();
 
     int exec();
 
@@ -57,23 +59,23 @@ public:
     // this should really only be used for integrating with other event loops
     void pump(WaitMode = WaitMode::WaitForEvents);
 
-    void post_event(CObject& receiver, NonnullOwnPtr<CEvent>&&);
+    void post_event(Object& receiver, NonnullOwnPtr<Event>&&);
 
-    static CEventLoop& main();
-    static CEventLoop& current();
+    static EventLoop& main();
+    static EventLoop& current();
 
     bool was_exit_requested() const { return m_exit_requested; }
 
-    static int register_timer(CObject&, int milliseconds, bool should_reload, TimerShouldFireWhenNotVisible);
+    static int register_timer(Object&, int milliseconds, bool should_reload, TimerShouldFireWhenNotVisible);
     static bool unregister_timer(int timer_id);
 
-    static void register_notifier(Badge<CNotifier>, CNotifier&);
-    static void unregister_notifier(Badge<CNotifier>, CNotifier&);
+    static void register_notifier(Badge<Notifier>, Notifier&);
+    static void unregister_notifier(Badge<Notifier>, Notifier&);
 
     void quit(int);
     void unquit();
 
-    void take_pending_events_from(CEventLoop& other)
+    void take_pending_events_from(EventLoop& other)
     {
         m_queued_events.append(move(other.m_queued_events));
     }
@@ -85,8 +87,8 @@ private:
     void get_next_timer_expiration(timeval&);
 
     struct QueuedEvent {
-        WeakPtr<CObject> receiver;
-        NonnullOwnPtr<CEvent> event;
+        WeakPtr<Object> receiver;
+        NonnullOwnPtr<Event> event;
     };
 
     Vector<QueuedEvent, 64> m_queued_events;
@@ -104,7 +106,7 @@ private:
         timeval fire_time { 0, 0 };
         bool should_reload { false };
         TimerShouldFireWhenNotVisible fire_when_not_visible { TimerShouldFireWhenNotVisible::No };
-        WeakPtr<CObject> owner;
+        WeakPtr<Object> owner;
 
         void reload(const timeval& now);
         bool has_expired(const timeval& now) const;
@@ -112,7 +114,9 @@ private:
 
     static HashMap<int, NonnullOwnPtr<EventLoopTimer>>* s_timers;
 
-    static HashTable<CNotifier*>* s_notifiers;
+    static HashTable<Notifier*>* s_notifiers;
 
-    static RefPtr<CLocalServer> s_rpc_server;
+    static RefPtr<LocalServer> s_rpc_server;
 };
+
+}
diff --git a/Libraries/LibCore/CFile.cpp b/Libraries/LibCore/CFile.cpp
index 781f1e4222..89a43bbe43 100644
--- a/Libraries/LibCore/CFile.cpp
+++ b/Libraries/LibCore/CFile.cpp
@@ -30,19 +30,21 @@
 #include <stdio.h>
 #include <unistd.h>
 
-CFile::CFile(const StringView& filename, CObject* parent)
-    : CIODevice(parent)
+namespace Core {
+
+File::File(const StringView& filename, Object* parent)
+    : IODevice(parent)
     , m_filename(filename)
 {
 }
 
-CFile::~CFile()
+File::~File()
 {
     if (m_should_close_file_descriptor == ShouldCloseFileDescription::Yes && mode() != NotOpen)
         close();
 }
 
-bool CFile::open(int fd, CIODevice::OpenMode mode, ShouldCloseFileDescription should_close)
+bool File::open(int fd, IODevice::OpenMode mode, ShouldCloseFileDescription should_close)
 {
     set_fd(fd);
     set_mode(mode);
@@ -50,25 +52,25 @@ bool CFile::open(int fd, CIODevice::OpenMode mode, ShouldCloseFileDescription sh
     return true;
 }
 
-bool CFile::open(CIODevice::OpenMode mode)
+bool File::open(IODevice::OpenMode mode)
 {
     ASSERT(!m_filename.is_null());
     int flags = 0;
-    if ((mode & CIODevice::ReadWrite) == CIODevice::ReadWrite) {
+    if ((mode & IODevice::ReadWrite) == IODevice::ReadWrite) {
         flags |= O_RDWR | O_CREAT;
-    } else if (mode & CIODevice::ReadOnly) {
+    } else if (mode & IODevice::ReadOnly) {
         flags |= O_RDONLY;
-    } else if (mode & CIODevice::WriteOnly) {
+    } else if (mode & IODevice::WriteOnly) {
         flags |= O_WRONLY | O_CREAT;
-        bool should_truncate = !((mode & CIODevice::Append) || (mode & CIODevice::MustBeNew));
+        bool should_truncate = !((mode & IODevice::Append) || (mode & IODevice::MustBeNew));
         if (should_truncate)
             flags |= O_TRUNC;
     }
-    if (mode & CIODevice::Append)
+    if (mode & IODevice::Append)
         flags |= O_APPEND;
-    if (mode & CIODevice::Truncate)
+    if (mode & IODevice::Truncate)
         flags |= O_TRUNC;
-    if (mode & CIODevice::MustBeNew)
+    if (mode & IODevice::MustBeNew)
         flags |= O_EXCL;
     int fd = ::open(m_filename.characters(), flags, 0666);
     if (fd < 0) {
@@ -80,3 +82,5 @@ bool CFile::open(CIODevice::OpenMode mode)
     set_mode(mode);
     return true;
 }
+
+}
diff --git a/Libraries/LibCore/CFile.h b/Libraries/LibCore/CFile.h
index 5e2391ba36..9c5da06f29 100644
--- a/Libraries/LibCore/CFile.h
+++ b/Libraries/LibCore/CFile.h
@@ -29,29 +29,33 @@
 #include <AK/String.h>
 #include <LibCore/CIODevice.h>
 
-class CFile final : public CIODevice {
-    C_OBJECT(CFile)
+namespace Core {
+
+class File final : public IODevice {
+    C_OBJECT(File)
 public:
-    virtual ~CFile() override;
+    virtual ~File() override;
 
     String filename() const { return m_filename; }
     void set_filename(const StringView& filename) { m_filename = filename; }
 
-    virtual bool open(CIODevice::OpenMode) override;
+    virtual bool open(IODevice::OpenMode) override;
 
     enum class ShouldCloseFileDescription {
         No = 0,
         Yes
     };
-    bool open(int fd, CIODevice::OpenMode, ShouldCloseFileDescription);
+    bool open(int fd, IODevice::OpenMode, ShouldCloseFileDescription);
 
 private:
-    CFile(CObject* parent = nullptr)
-        : CIODevice(parent)
+    File(Object* parent = nullptr)
+        : IODevice(parent)
     {
     }
-    explicit CFile(const StringView&, CObject* parent = nullptr);
+    explicit File(const StringView&, Object* parent = nullptr);
 
     String m_filename;
     ShouldCloseFileDescription m_should_close_file_descriptor { ShouldCloseFileDescription::Yes };
 };
+
+}
diff --git a/Libraries/LibCore/CHttpJob.cpp b/Libraries/LibCore/CHttpJob.cpp
index 02780f3d3c..624ed73254 100644
--- a/Libraries/LibCore/CHttpJob.cpp
+++ b/Libraries/LibCore/CHttpJob.cpp
@@ -33,6 +33,8 @@
 
 //#define CHTTPJOB_DEBUG
 
+namespace Core {
+
 static ByteBuffer handle_content_encoding(const ByteBuffer& buf, const String& content_encoding)
 {
 #ifdef CHTTPJOB_DEBUG
@@ -66,16 +68,16 @@ static ByteBuffer handle_content_encoding(const ByteBuffer& buf, const String& c
     return buf;
 }
 
-CHttpJob::CHttpJob(const CHttpRequest& request)
+HttpJob::HttpJob(const HttpRequest& request)
     : m_request(request)
 {
 }
 
-CHttpJob::~CHttpJob()
+HttpJob::~HttpJob()
 {
 }
 
-void CHttpJob::on_socket_connected()
+void HttpJob::on_socket_connected()
 {
     auto raw_request = m_request.to_raw_request();
 #if 0
@@ -85,7 +87,7 @@ void CHttpJob::on_socket_connected()
 
     bool success = m_socket->send(raw_request);
     if (!success)
-        return deferred_invoke([this](auto&) { did_fail(CNetworkJob::Error::TransmissionFailed); });
+        return deferred_invoke([this](auto&) { did_fail(NetworkJob::Error::TransmissionFailed); });
 
     m_socket->on_ready_to_read = [&] {
         if (is_cancelled())
@@ -96,18 +98,18 @@ void CHttpJob::on_socket_connected()
             auto line = m_socket->read_line(PAGE_SIZE);
             if (line.is_null()) {
                 fprintf(stderr, "CHttpJob: Expected HTTP status\n");
-                return deferred_invoke([this](auto&) { did_fail(CNetworkJob::Error::TransmissionFailed); });
+                return deferred_invoke([this](auto&) { did_fail(NetworkJob::Error::TransmissionFailed); });
             }
             auto parts = String::copy(line, Chomp).split(' ');
             if (parts.size() < 3) {
                 fprintf(stderr, "CHttpJob: Expected 3-part HTTP status, got '%s'\n", line.data());
-                return deferred_invoke([this](auto&) { did_fail(CNetworkJob::Error::ProtocolFailed); });
+                return deferred_invoke([this](auto&) { did_fail(NetworkJob::Error::ProtocolFailed); });
             }
             bool ok;
             m_code = parts[1].to_uint(ok);
             if (!ok) {
                 fprintf(stderr, "CHttpJob: Expected numeric HTTP status\n");
-                return deferred_invoke([this](auto&) { did_fail(CNetworkJob::Error::ProtocolFailed); });
+                return deferred_invoke([this](auto&) { did_fail(NetworkJob::Error::ProtocolFailed); });
             }
             m_state = State::InHeaders;
             return;
@@ -118,7 +120,7 @@ void CHttpJob::on_socket_connected()
             auto line = m_socket->read_line(PAGE_SIZE);
             if (line.is_null()) {
                 fprintf(stderr, "CHttpJob: Expected HTTP header\n");
-                return did_fail(CNetworkJob::Error::ProtocolFailed);
+                return did_fail(NetworkJob::Error::ProtocolFailed);
             }
             auto chomped_line = String::copy(line, Chomp);
             if (chomped_line.is_empty()) {
@@ -128,12 +130,12 @@ void CHttpJob::on_socket_connected()
             auto parts = chomped_line.split(':');
             if (parts.is_empty()) {
                 fprintf(stderr, "CHttpJob: Expected HTTP header with key/value\n");
-                return deferred_invoke([this](auto&) { did_fail(CNetworkJob::Error::ProtocolFailed); });
+                return deferred_invoke([this](auto&) { did_fail(NetworkJob::Error::ProtocolFailed); });
             }
             auto name = parts[0];
             if (chomped_line.length() < name.length() + 2) {
                 fprintf(stderr, "CHttpJob: Malformed HTTP header: '%s' (%zu)\n", chomped_line.characters(), chomped_line.length());
-                return deferred_invoke([this](auto&) { did_fail(CNetworkJob::Error::ProtocolFailed); });
+                return deferred_invoke([this](auto&) { did_fail(NetworkJob::Error::ProtocolFailed); });
             }
             auto value = chomped_line.substring(name.length() + 2, chomped_line.length() - name.length() - 2);
             m_headers.set(name, value);
@@ -148,7 +150,7 @@ void CHttpJob::on_socket_connected()
         if (!payload) {
             if (m_socket->eof())
                 return finish_up();
-            return deferred_invoke([this](auto&) { did_fail(CNetworkJob::Error::ProtocolFailed); });
+            return deferred_invoke([this](auto&) { did_fail(NetworkJob::Error::ProtocolFailed); });
         }
         m_received_buffers.append(payload);
         m_received_size += payload.size();
@@ -162,7 +164,7 @@ void CHttpJob::on_socket_connected()
     };
 }
 
-void CHttpJob::finish_up()
+void HttpJob::finish_up()
 {
     m_state = State::Finished;
     auto flattened_buffer = ByteBuffer::create_uninitialized(m_received_size);
@@ -178,16 +180,16 @@ void CHttpJob::finish_up()
         flattened_buffer = handle_content_encoding(flattened_buffer, content_encoding.value());
     }
 
-    auto response = CHttpResponse::create(m_code, move(m_headers), move(flattened_buffer));
+    auto response = HttpResponse::create(m_code, move(m_headers), move(flattened_buffer));
     deferred_invoke([this, response](auto&) {
         did_finish(move(response));
     });
 }
 
-void CHttpJob::start()
+void HttpJob::start()
 {
     ASSERT(!m_socket);
-    m_socket = CTCPSocket::construct(this);
+    m_socket = TCPSocket::construct(this);
     m_socket->on_connected = [this] {
 #ifdef CHTTPJOB_DEBUG
         dbg() << "CHttpJob: on_connected callback";
@@ -197,12 +199,12 @@ void CHttpJob::start()
     bool success = m_socket->connect(m_request.url().host(), m_request.url().port());
     if (!success) {
         deferred_invoke([this](auto&) {
-            return did_fail(CNetworkJob::Error::ConnectionFailed);
+            return did_fail(NetworkJob::Error::ConnectionFailed);
         });
     }
 }
 
-void CHttpJob::shutdown()
+void HttpJob::shutdown()
 {
     if (!m_socket)
         return;
@@ -211,3 +213,4 @@ void CHttpJob::shutdown()
     remove_child(*m_socket);
     m_socket = nullptr;
 }
+}
diff --git a/Libraries/LibCore/CHttpJob.h b/Libraries/LibCore/CHttpJob.h
index 2fb2c34ea9..549892c060 100644
--- a/Libraries/LibCore/CHttpJob.h
+++ b/Libraries/LibCore/CHttpJob.h
@@ -31,19 +31,21 @@
 #include <LibCore/CHttpResponse.h>
 #include <LibCore/CNetworkJob.h>
 
-class CTCPSocket;
+namespace Core {
 
-class CHttpJob final : public CNetworkJob {
-    C_OBJECT(CHttpJob)
+class TCPSocket;
+
+class HttpJob final : public NetworkJob {
+    C_OBJECT(HttpJob)
 public:
-    explicit CHttpJob(const CHttpRequest&);
-    virtual ~CHttpJob() override;
+    explicit HttpJob(const HttpRequest&);
+    virtual ~HttpJob() override;
 
     virtual void start() override;
     virtual void shutdown() override;
 
-    CHttpResponse* response() { return static_cast<CHttpResponse*>(CNetworkJob::response()); }
-    const CHttpResponse* response() const { return static_cast<const CHttpResponse*>(CNetworkJob::response()); }
+    HttpResponse* response() { return static_cast<HttpResponse*>(NetworkJob::response()); }
+    const HttpResponse* response() const { return static_cast<const HttpResponse*>(NetworkJob::response()); }
 
 private:
     void on_socket_connected();
@@ -56,11 +58,13 @@ private:
         Finished,
     };
 
-    CHttpRequest m_request;
-    RefPtr<CTCPSocket> m_socket;
+    HttpRequest m_request;
+    RefPtr<TCPSocket> m_socket;
     State m_state { State::InStatus };
     int m_code { -1 };
     HashMap<String, String> m_headers;
     Vector<ByteBuffer> m_received_buffers;
     size_t m_received_size { 0 };
 };
+
+}
diff --git a/Libraries/LibCore/CHttpRequest.cpp b/Libraries/LibCore/CHttpRequest.cpp
index b2c0fbb1c9..99899427ac 100644
--- a/Libraries/LibCore/CHttpRequest.cpp
+++ b/Libraries/LibCore/CHttpRequest.cpp
@@ -28,22 +28,24 @@
 #include <LibCore/CHttpJob.h>
 #include <LibCore/CHttpRequest.h>
 
-CHttpRequest::CHttpRequest()
+namespace Core {
+
+HttpRequest::HttpRequest()
 {
 }
 
-CHttpRequest::~CHttpRequest()
+HttpRequest::~HttpRequest()
 {
 }
 
-RefPtr<CNetworkJob> CHttpRequest::schedule()
+RefPtr<NetworkJob> HttpRequest::schedule()
 {
-    auto job = CHttpJob::construct(*this);
+    auto job = HttpJob::construct(*this);
     job->start();
     return job;
 }
 
-String CHttpRequest::method_name() const
+String HttpRequest::method_name() const
 {
     switch (m_method) {
     case Method::GET:
@@ -57,7 +59,7 @@ String CHttpRequest::method_name() const
     }
 }
 
-ByteBuffer CHttpRequest::to_raw_request() const
+ByteBuffer HttpRequest::to_raw_request() const
 {
     StringBuilder builder;
     builder.append(method_name());
@@ -68,3 +70,5 @@ ByteBuffer CHttpRequest::to_raw_request() const
     builder.append("\r\n\r\n");
     return builder.to_byte_buffer();
 }
+
+}
diff --git a/Libraries/LibCore/CHttpRequest.h b/Libraries/LibCore/CHttpRequest.h
index 293605833d..fe4feafd14 100644
--- a/Libraries/LibCore/CHttpRequest.h
+++ b/Libraries/LibCore/CHttpRequest.h
@@ -29,9 +29,11 @@
 #include <AK/String.h>
 #include <AK/URL.h>
 
-class CNetworkJob;
+namespace Core {
 
-class CHttpRequest {
+class NetworkJob;
+
+class HttpRequest {
 public:
     enum Method {
         Invalid,
@@ -40,8 +42,8 @@ public:
         POST
     };
 
-    CHttpRequest();
-    ~CHttpRequest();
+    HttpRequest();
+    ~HttpRequest();
 
     const URL& url() const { return m_url; }
     void set_url(const URL& url) { m_url = url; }
@@ -52,9 +54,11 @@ public:
     String method_name() const;
     ByteBuffer to_raw_request() const;
 
-    RefPtr<CNetworkJob> schedule();
+    RefPtr<NetworkJob> schedule();
 
 private:
     URL m_url;
     Method m_method { GET };
 };
+
+}
diff --git a/Libraries/LibCore/CHttpResponse.cpp b/Libraries/LibCore/CHttpResponse.cpp
index fdd0b9c3af..064da3d2ba 100644
--- a/Libraries/LibCore/CHttpResponse.cpp
+++ b/Libraries/LibCore/CHttpResponse.cpp
@@ -26,13 +26,17 @@
 
 #include <LibCore/CHttpResponse.h>
 
-CHttpResponse::CHttpResponse(int code, HashMap<String, String>&& headers, ByteBuffer&& payload)
-    : CNetworkResponse(move(payload))
+namespace Core {
+
+HttpResponse::HttpResponse(int code, HashMap<String, String>&& headers, ByteBuffer&& payload)
+    : NetworkResponse(move(payload))
     , m_code(code)
     , m_headers(move(headers))
 {
 }
 
-CHttpResponse::~CHttpResponse()
+HttpResponse::~HttpResponse()
 {
 }
+
+}
diff --git a/Libraries/LibCore/CHttpResponse.h b/Libraries/LibCore/CHttpResponse.h
index 1bdf30b0bb..65d72f11ab 100644
--- a/Libraries/LibCore/CHttpResponse.h
+++ b/Libraries/LibCore/CHttpResponse.h
@@ -26,24 +26,28 @@
 
 #pragma once
 
-#include <AK/String.h>
 #include <AK/HashMap.h>
+#include <AK/String.h>
 #include <LibCore/CNetworkResponse.h>
 
-class CHttpResponse : public CNetworkResponse {
+namespace Core {
+
+class HttpResponse : public NetworkResponse {
 public:
-    virtual ~CHttpResponse() override;
-    static NonnullRefPtr<CHttpResponse> create(int code, HashMap<String, String>&& headers, ByteBuffer&& payload)
+    virtual ~HttpResponse() override;
+    static NonnullRefPtr<HttpResponse> create(int code, HashMap<String, String>&& headers, ByteBuffer&& payload)
     {
-        return adopt(*new CHttpResponse(code, move(headers), move(payload)));
+        return adopt(*new HttpResponse(code, move(headers), move(payload)));
     }
 
     int code() const { return m_code; }
     const HashMap<String, String>& headers() const { return m_headers; }
 
 private:
-    CHttpResponse(int code, HashMap<String, String>&&, ByteBuffer&&);
+    HttpResponse(int code, HashMap<String, String>&&, ByteBuffer&&);
 
     int m_code { 0 };
     HashMap<String, String> m_headers;
 };
+
+}
diff --git a/Libraries/LibCore/CIODevice.cpp b/Libraries/LibCore/CIODevice.cpp
index 20ea105b8c..03666b0bfa 100644
--- a/Libraries/LibCore/CIODevice.cpp
+++ b/Libraries/LibCore/CIODevice.cpp
@@ -34,21 +34,23 @@
 #include <sys/time.h>
 #include <unistd.h>
 
-CIODevice::CIODevice(CObject* parent)
-    : CObject(parent)
+namespace Core {
+
+IODevice::IODevice(Object* parent)
+    : Object(parent)
 {
 }
 
-CIODevice::~CIODevice()
+IODevice::~IODevice()
 {
 }
 
-const char* CIODevice::error_string() const
+const char* IODevice::error_string() const
 {
     return strerror(m_error);
 }
 
-int CIODevice::read(u8* buffer, int length)
+int IODevice::read(u8* buffer, int length)
 {
     auto read_buffer = read(length);
     if (read_buffer.is_null())
@@ -57,7 +59,7 @@ int CIODevice::read(u8* buffer, int length)
     return read_buffer.size();
 }
 
-ByteBuffer CIODevice::read(int max_size)
+ByteBuffer IODevice::read(int max_size)
 {
     if (m_fd < 0)
         return {};
@@ -99,7 +101,7 @@ ByteBuffer CIODevice::read(int max_size)
     return buffer;
 }
 
-bool CIODevice::can_read_from_fd() const
+bool IODevice::can_read_from_fd() const
 {
     // FIXME: Can we somehow remove this once CSocket is implemented using non-blocking sockets?
     fd_set rfds;
@@ -111,13 +113,13 @@ bool CIODevice::can_read_from_fd() const
     int rc = CSyscallUtils::safe_syscall(select, m_fd + 1, &rfds, nullptr, nullptr, &timeout);
     if (rc < 0) {
         // NOTE: We don't set m_error here.
-        perror("CIODevice::can_read: select");
+        perror("IODevice::can_read: select");
         return false;
     }
     return FD_ISSET(m_fd, &rfds);
 }
 
-bool CIODevice::can_read_line()
+bool IODevice::can_read_line()
 {
     if (m_eof && !m_buffered_data.is_empty())
         return true;
@@ -129,12 +131,12 @@ bool CIODevice::can_read_line()
     return m_buffered_data.contains_slow('\n');
 }
 
-bool CIODevice::can_read() const
+bool IODevice::can_read() const
 {
     return !m_buffered_data.is_empty() || can_read_from_fd();
 }
 
-ByteBuffer CIODevice::read_all()
+ByteBuffer IODevice::read_all()
 {
     off_t file_size = 0;
     struct stat st;
@@ -168,7 +170,7 @@ ByteBuffer CIODevice::read_all()
     return ByteBuffer::copy(data.data(), data.size());
 }
 
-ByteBuffer CIODevice::read_line(int max_size)
+ByteBuffer IODevice::read_line(int max_size)
 {
     if (m_fd < 0)
         return {};
@@ -178,7 +180,7 @@ ByteBuffer CIODevice::read_line(int max_size)
         return {};
     if (m_eof) {
         if (m_buffered_data.size() > max_size) {
-            dbgprintf("CIODevice::read_line: At EOF but there's more than max_size(%d) buffered\n", max_size);
+            dbgprintf("IODevice::read_line: At EOF but there's more than max_size(%d) buffered\n", max_size);
             return {};
         }
         auto buffer = ByteBuffer::copy(m_buffered_data.data(), m_buffered_data.size());
@@ -202,7 +204,7 @@ ByteBuffer CIODevice::read_line(int max_size)
     return {};
 }
 
-bool CIODevice::populate_read_buffer()
+bool IODevice::populate_read_buffer()
 {
     if (m_fd < 0)
         return false;
@@ -220,7 +222,7 @@ bool CIODevice::populate_read_buffer()
     return true;
 }
 
-bool CIODevice::close()
+bool IODevice::close()
 {
     if (fd() < 0 || mode() == NotOpen)
         return false;
@@ -230,11 +232,11 @@ bool CIODevice::close()
         return false;
     }
     set_fd(-1);
-    set_mode(CIODevice::NotOpen);
+    set_mode(IODevice::NotOpen);
     return true;
 }
 
-bool CIODevice::seek(i64 offset, SeekMode mode, off_t* pos)
+bool IODevice::seek(i64 offset, SeekMode mode, off_t* pos)
 {
     int m = SEEK_SET;
     switch (mode) {
@@ -262,18 +264,18 @@ bool CIODevice::seek(i64 offset, SeekMode mode, off_t* pos)
     return true;
 }
 
-bool CIODevice::write(const u8* data, int size)
+bool IODevice::write(const u8* data, int size)
 {
     int rc = ::write(m_fd, data, size);
     if (rc < 0) {
-        perror("CIODevice::write: write");
+        perror("IODevice::write: write");
         set_error(errno);
         return false;
     }
     return rc == size;
 }
 
-int CIODevice::printf(const char* format, ...)
+int IODevice::printf(const char* format, ...)
 {
     va_list ap;
     va_start(ap, format);
@@ -286,7 +288,7 @@ int CIODevice::printf(const char* format, ...)
     return ret;
 }
 
-void CIODevice::set_fd(int fd)
+void IODevice::set_fd(int fd)
 {
     if (m_fd == fd)
         return;
@@ -294,3 +296,4 @@ void CIODevice::set_fd(int fd)
     m_fd = fd;
     did_update_fd(fd);
 }
+}
diff --git a/Libraries/LibCore/CIODevice.h b/Libraries/LibCore/CIODevice.h
index 68b0c1b9c5..ac4d753e2b 100644
--- a/Libraries/LibCore/CIODevice.h
+++ b/Libraries/LibCore/CIODevice.h
@@ -30,8 +30,10 @@
 #include <AK/StringView.h>
 #include <LibCore/CObject.h>
 
-class CIODevice : public CObject {
-    C_OBJECT_ABSTRACT(CIODevice)
+namespace Core {
+
+class IODevice : public Object {
+    C_OBJECT_ABSTRACT(IODevice)
 public:
     enum OpenMode {
         NotOpen = 0,
@@ -43,7 +45,7 @@ public:
         MustBeNew = 16,
     };
 
-    virtual ~CIODevice() override;
+    virtual ~IODevice() override;
 
     int fd() const { return m_fd; }
     unsigned mode() const { return m_mode; }
@@ -55,7 +57,6 @@ public:
 
     bool has_error() const { return m_error != 0; }
 
-
     int read(u8* buffer, int length);
 
     ByteBuffer read(int max_size);
@@ -78,13 +79,13 @@ public:
 
     bool seek(i64, SeekMode = SeekMode::SetPosition, off_t* = nullptr);
 
-    virtual bool open(CIODevice::OpenMode) = 0;
+    virtual bool open(IODevice::OpenMode) = 0;
     virtual bool close();
 
     int printf(const char*, ...);
 
 protected:
-    explicit CIODevice(CObject* parent = nullptr);
+    explicit IODevice(Object* parent = nullptr);
 
     void set_fd(int);
     void set_mode(OpenMode mode) { m_mode = mode; }
@@ -103,3 +104,5 @@ private:
     OpenMode m_mode { NotOpen };
     Vector<u8> m_buffered_data;
 };
+
+}
diff --git a/Libraries/LibCore/CIODeviceStreamReader.h b/Libraries/LibCore/CIODeviceStreamReader.h
index 24606d96dd..a7318ce8b7 100644
--- a/Libraries/LibCore/CIODeviceStreamReader.h
+++ b/Libraries/LibCore/CIODeviceStreamReader.h
@@ -29,9 +29,11 @@
 #include <AK/StdLibExtras.h>
 #include <LibCore/CIODevice.h>
 
-class CIODeviceStreamReader {
+namespace Core {
+
+class IODeviceStreamReader {
 public:
-    CIODeviceStreamReader(CIODevice& device)
+    IODeviceStreamReader(IODevice& device)
         : m_device(device)
     {
     }
@@ -42,7 +44,7 @@ public:
     }
 
     template<typename T>
-    CIODeviceStreamReader& operator>>(T& value)
+    IODeviceStreamReader& operator>>(T& value)
     {
         int nread = m_device.read((u8*)&value, sizeof(T));
         ASSERT(nread == sizeof(T));
@@ -52,6 +54,8 @@ public:
     }
 
 private:
-    CIODevice& m_device;
+    IODevice& m_device;
     bool m_had_failure { false };
 };
+
+}
diff --git a/Libraries/LibCore/CLocalServer.cpp b/Libraries/LibCore/CLocalServer.cpp
index 316a49aded..0f03ee0ab8 100644
--- a/Libraries/LibCore/CLocalServer.cpp
+++ b/Libraries/LibCore/CLocalServer.cpp
@@ -35,16 +35,18 @@
 #include <sys/ioctl.h>
 #endif
 
-CLocalServer::CLocalServer(CObject* parent)
-    : CObject(parent)
+namespace Core {
+
+LocalServer::LocalServer(Object* parent)
+    : Object(parent)
 {
 }
 
-CLocalServer::~CLocalServer()
+LocalServer::~LocalServer()
 {
 }
 
-bool CLocalServer::take_over_from_system_server()
+bool LocalServer::take_over_from_system_server()
 {
     if (m_listening)
         return false;
@@ -84,16 +86,16 @@ bool CLocalServer::take_over_from_system_server()
     return false;
 }
 
-void CLocalServer::setup_notifier()
+void LocalServer::setup_notifier()
 {
-    m_notifier = CNotifier::construct(m_fd, CNotifier::Event::Read, this);
+    m_notifier = Notifier::construct(m_fd, Notifier::Event::Read, this);
     m_notifier->on_ready_to_read = [this] {
         if (on_ready_to_accept)
             on_ready_to_accept();
     };
 }
 
-bool CLocalServer::listen(const String& address)
+bool LocalServer::listen(const String& address)
 {
     if (m_listening)
         return false;
@@ -116,7 +118,7 @@ bool CLocalServer::listen(const String& address)
         ASSERT_NOT_REACHED();
     }
 
-    auto socket_address = CSocketAddress::local(address);
+    auto socket_address = SocketAddress::local(address);
     auto un = socket_address.to_sockaddr_un();
     rc = ::bind(m_fd, (const sockaddr*)&un, sizeof(un));
     if (rc < 0) {
@@ -135,7 +137,7 @@ bool CLocalServer::listen(const String& address)
     return true;
 }
 
-RefPtr<CLocalSocket> CLocalServer::accept()
+RefPtr<LocalSocket> LocalServer::accept()
 {
     ASSERT(m_listening);
     sockaddr_un un;
@@ -146,5 +148,7 @@ RefPtr<CLocalSocket> CLocalServer::accept()
         return nullptr;
     }
 
-    return CLocalSocket::construct(accepted_fd);
+    return LocalSocket::construct(accepted_fd);
+}
+
 }
diff --git a/Libraries/LibCore/CLocalServer.h b/Libraries/LibCore/CLocalServer.h
index 1c00adb824..05ee7942ca 100644
--- a/Libraries/LibCore/CLocalServer.h
+++ b/Libraries/LibCore/CLocalServer.h
@@ -29,27 +29,31 @@
 #include <LibCore/CNotifier.h>
 #include <LibCore/CObject.h>
 
-class CLocalSocket;
+namespace Core {
 
-class CLocalServer : public CObject {
-    C_OBJECT(CLocalServer)
+class LocalSocket;
+
+class LocalServer : public Object {
+    C_OBJECT(LocalServer)
 public:
-    virtual ~CLocalServer() override;
+    virtual ~LocalServer() override;
 
     bool take_over_from_system_server();
     bool is_listening() const { return m_listening; }
     bool listen(const String& address);
 
-    RefPtr<CLocalSocket> accept();
+    RefPtr<LocalSocket> accept();
 
     Function<void()> on_ready_to_accept;
 
 private:
-    explicit CLocalServer(CObject* parent = nullptr);
+    explicit LocalServer(Object* parent = nullptr);
 
     void setup_notifier();
 
     int m_fd { -1 };
     bool m_listening { false };
-    RefPtr<CNotifier> m_notifier;
+    RefPtr<Notifier> m_notifier;
 };
+
+}
diff --git a/Libraries/LibCore/CLocalSocket.cpp b/Libraries/LibCore/CLocalSocket.cpp
index d957c24d3f..c9e92eceb8 100644
--- a/Libraries/LibCore/CLocalSocket.cpp
+++ b/Libraries/LibCore/CLocalSocket.cpp
@@ -25,27 +25,29 @@
  */
 
 #include <LibCore/CLocalSocket.h>
-#include <sys/socket.h>
 #include <errno.h>
+#include <sys/socket.h>
 
 #ifndef SOCK_NONBLOCK
-#include <sys/ioctl.h>
+#    include <sys/ioctl.h>
 #endif
 
-CLocalSocket::CLocalSocket(int fd, CObject* parent)
-    : CSocket(CSocket::Type::Local, parent)
+namespace Core {
+
+LocalSocket::LocalSocket(int fd, Object* parent)
+    : Socket(Socket::Type::Local, parent)
 {
     // NOTE: This constructor is used by CLocalServer::accept(), so the socket is already connected.
     m_connected = true;
     set_fd(fd);
-    set_mode(CIODevice::ReadWrite);
+    set_mode(IODevice::ReadWrite);
     set_error(0);
 }
 
-CLocalSocket::CLocalSocket(CObject* parent)
-    : CSocket(CSocket::Type::Local, parent)
+LocalSocket::LocalSocket(Object* parent)
+    : Socket(Socket::Type::Local, parent)
 {
-    
+
 #ifdef SOCK_NONBLOCK
     int fd = socket(AF_LOCAL, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
 #else
@@ -59,11 +61,13 @@ CLocalSocket::CLocalSocket(CObject* parent)
         set_error(errno);
     } else {
         set_fd(fd);
-        set_mode(CIODevice::ReadWrite);
+        set_mode(IODevice::ReadWrite);
         set_error(0);
     }
 }
 
-CLocalSocket::~CLocalSocket()
+LocalSocket::~LocalSocket()
 {
 }
+
+}
diff --git a/Libraries/LibCore/CLocalSocket.h b/Libraries/LibCore/CLocalSocket.h
index 428c37ca2b..6d32bc3395 100644
--- a/Libraries/LibCore/CLocalSocket.h
+++ b/Libraries/LibCore/CLocalSocket.h
@@ -29,14 +29,18 @@
 #include <AK/Badge.h>
 #include <LibCore/CSocket.h>
 
-class CLocalServer;
+namespace Core {
 
-class CLocalSocket final : public CSocket {
-    C_OBJECT(CLocalSocket)
+class LocalServer;
+
+class LocalSocket final : public Socket {
+    C_OBJECT(LocalSocket)
 public:
-    virtual ~CLocalSocket() override;
+    virtual ~LocalSocket() override;
 
 private:
-    explicit CLocalSocket(CObject* parent = nullptr);
-    CLocalSocket(int fd, CObject* parent = nullptr);
+    explicit LocalSocket(Object* parent = nullptr);
+    LocalSocket(int fd, Object* parent = nullptr);
 };
+
+}
diff --git a/Libraries/LibCore/CNetworkJob.cpp b/Libraries/LibCore/CNetworkJob.cpp
index 6e39b15a7d..e8be9a421c 100644
--- a/Libraries/LibCore/CNetworkJob.cpp
+++ b/Libraries/LibCore/CNetworkJob.cpp
@@ -30,19 +30,21 @@
 
 //#define CNETWORKJOB_DEBUG
 
-CNetworkJob::CNetworkJob()
+namespace Core {
+
+NetworkJob::NetworkJob()
 {
 }
 
-CNetworkJob::~CNetworkJob()
+NetworkJob::~NetworkJob()
 {
 }
 
-void CNetworkJob::did_finish(NonnullRefPtr<CNetworkResponse>&& response)
+void NetworkJob::did_finish(NonnullRefPtr<NetworkResponse>&& response)
 {
     // NOTE: We protect ourselves here, since the on_finish callback may otherwise
     //       trigger destruction of this job somehow.
-    NonnullRefPtr<CNetworkJob> protector(*this);
+    NonnullRefPtr<NetworkJob> protector(*this);
 
     m_response = move(response);
 #ifdef CNETWORKJOB_DEBUG
@@ -53,11 +55,11 @@ void CNetworkJob::did_finish(NonnullRefPtr<CNetworkResponse>&& response)
     shutdown();
 }
 
-void CNetworkJob::did_fail(Error error)
+void NetworkJob::did_fail(Error error)
 {
     // NOTE: We protect ourselves here, since the on_finish callback may otherwise
     //       trigger destruction of this job somehow.
-    NonnullRefPtr<CNetworkJob> protector(*this);
+    NonnullRefPtr<NetworkJob> protector(*this);
 
     m_error = error;
 #ifdef CNETWORKJOB_DEBUG
@@ -68,18 +70,20 @@ void CNetworkJob::did_fail(Error error)
     shutdown();
 }
 
-const char* to_string(CNetworkJob::Error error)
+const char* to_string(NetworkJob::Error error)
 {
     switch (error) {
-    case CNetworkJob::Error::ProtocolFailed:
+    case NetworkJob::Error::ProtocolFailed:
         return "ProtocolFailed";
-    case CNetworkJob::Error::ConnectionFailed:
+    case NetworkJob::Error::ConnectionFailed:
         return "ConnectionFailed";
-    case CNetworkJob::Error::TransmissionFailed:
+    case NetworkJob::Error::TransmissionFailed:
         return "TransmissionFailed";
-    case CNetworkJob::Error::Cancelled:
+    case NetworkJob::Error::Cancelled:
         return "Cancelled";
     default:
         return "(Unknown error)";
     }
 }
+
+}
diff --git a/Libraries/LibCore/CNetworkJob.h b/Libraries/LibCore/CNetworkJob.h
index be1862a0f5..9c2dcad14c 100644
--- a/Libraries/LibCore/CNetworkJob.h
+++ b/Libraries/LibCore/CNetworkJob.h
@@ -29,10 +29,12 @@
 #include <AK/Function.h>
 #include <LibCore/CObject.h>
 
-class CNetworkResponse;
+namespace Core {
 
-class CNetworkJob : public CObject {
-    C_OBJECT(CNetworkJob)
+class NetworkResponse;
+
+class NetworkJob : public Object {
+    C_OBJECT_ABSTRACT(NetworkJob)
 public:
     enum class Error {
         None,
@@ -41,15 +43,15 @@ public:
         ProtocolFailed,
         Cancelled,
     };
-    virtual ~CNetworkJob() override;
+    virtual ~NetworkJob() override;
 
     Function<void(bool success)> on_finish;
 
     bool is_cancelled() const { return m_error == Error::Cancelled; }
     bool has_error() const { return m_error != Error::None; }
     Error error() const { return m_error; }
-    CNetworkResponse* response() { return m_response.ptr(); }
-    const CNetworkResponse* response() const { return m_response.ptr(); }
+    NetworkResponse* response() { return m_response.ptr(); }
+    const NetworkResponse* response() const { return m_response.ptr(); }
 
     virtual void start() = 0;
     virtual void shutdown() = 0;
@@ -61,13 +63,15 @@ public:
     }
 
 protected:
-    CNetworkJob();
-    void did_finish(NonnullRefPtr<CNetworkResponse>&&);
+    NetworkJob();
+    void did_finish(NonnullRefPtr<NetworkResponse>&&);
     void did_fail(Error);
 
 private:
-    RefPtr<CNetworkResponse> m_response;
+    RefPtr<NetworkResponse> m_response;
     Error m_error { Error::None };
 };
 
-const char* to_string(CNetworkJob::Error);
+const char* to_string(NetworkJob::Error);
+
+}
diff --git a/Libraries/LibCore/CNetworkResponse.cpp b/Libraries/LibCore/CNetworkResponse.cpp
index 1fc52507f4..f61b559129 100644
--- a/Libraries/LibCore/CNetworkResponse.cpp
+++ b/Libraries/LibCore/CNetworkResponse.cpp
@@ -26,11 +26,15 @@
 
 #include <LibCore/CNetworkResponse.h>
 
-CNetworkResponse::CNetworkResponse(ByteBuffer&& payload)
+namespace Core {
+
+NetworkResponse::NetworkResponse(ByteBuffer&& payload)
     : m_payload(payload)
 {
 }
 
-CNetworkResponse::~CNetworkResponse()
+NetworkResponse::~NetworkResponse()
 {
 }
+
+}
diff --git a/Libraries/LibCore/CNetworkResponse.h b/Libraries/LibCore/CNetworkResponse.h
index 0431c567de..d39e2832eb 100644
--- a/Libraries/LibCore/CNetworkResponse.h
+++ b/Libraries/LibCore/CNetworkResponse.h
@@ -29,16 +29,20 @@
 #include <AK/ByteBuffer.h>
 #include <AK/RefCounted.h>
 
-class CNetworkResponse : public RefCounted<CNetworkResponse> {
+namespace Core {
+
+class NetworkResponse : public RefCounted<NetworkResponse> {
 public:
-    virtual ~CNetworkResponse();
+    virtual ~NetworkResponse();
 
     bool is_error() const { return m_error; }
     const ByteBuffer& payload() const { return m_payload; }
 
 protected:
-    explicit CNetworkResponse(ByteBuffer&&);
+    explicit NetworkResponse(ByteBuffer&&);
 
     bool m_error { false };
     ByteBuffer m_payload;
 };
+
+}
diff --git a/Libraries/LibCore/CNotifier.cpp b/Libraries/LibCore/CNotifier.cpp
index fd68858909..a02f317d19 100644
--- a/Libraries/LibCore/CNotifier.cpp
+++ b/Libraries/LibCore/CNotifier.cpp
@@ -28,34 +28,38 @@
 #include <LibCore/CEventLoop.h>
 #include <LibCore/CNotifier.h>
 
-CNotifier::CNotifier(int fd, unsigned event_mask, CObject* parent)
-    : CObject(parent)
+namespace Core {
+
+Notifier::Notifier(int fd, unsigned event_mask, Object* parent)
+    : Object(parent)
     , m_fd(fd)
     , m_event_mask(event_mask)
 {
     set_enabled(true);
 }
 
-CNotifier::~CNotifier()
+Notifier::~Notifier()
 {
     set_enabled(false);
 }
 
-void CNotifier::set_enabled(bool enabled)
+void Notifier::set_enabled(bool enabled)
 {
     if (enabled)
-        CEventLoop::register_notifier({}, *this);
+        Core::EventLoop::register_notifier({}, *this);
     else
-        CEventLoop::unregister_notifier({}, *this);
+        Core::EventLoop::unregister_notifier({}, *this);
 }
 
-void CNotifier::event(CEvent& event)
+void Notifier::event(Core::Event& event)
 {
-    if (event.type() == CEvent::NotifierRead && on_ready_to_read) {
+    if (event.type() == Core::Event::NotifierRead && on_ready_to_read) {
         on_ready_to_read();
-    } else if (event.type() == CEvent::NotifierWrite && on_ready_to_write) {
+    } else if (event.type() == Core::Event::NotifierWrite && on_ready_to_write) {
         on_ready_to_write();
     } else {
-        CObject::event(event);
+        Object::event(event);
     }
 }
+
+}
diff --git a/Libraries/LibCore/CNotifier.h b/Libraries/LibCore/CNotifier.h
index 820ac0bf77..9c21c3357a 100644
--- a/Libraries/LibCore/CNotifier.h
+++ b/Libraries/LibCore/CNotifier.h
@@ -29,8 +29,10 @@
 #include <AK/Function.h>
 #include <LibCore/CObject.h>
 
-class CNotifier : public CObject {
-    C_OBJECT(CNotifier)
+namespace Core {
+
+class Notifier : public Object {
+    C_OBJECT(Notifier)
 public:
     enum Event {
         None = 0,
@@ -39,7 +41,7 @@ public:
         Exceptional = 4,
     };
 
-    virtual ~CNotifier() override;
+    virtual ~Notifier() override;
 
     void set_enabled(bool);
 
@@ -50,11 +52,13 @@ public:
     unsigned event_mask() const { return m_event_mask; }
     void set_event_mask(unsigned event_mask) { m_event_mask = event_mask; }
 
-    void event(CEvent&) override;
+    void event(Core::Event&) override;
 
 private:
-    CNotifier(int fd, unsigned event_mask, CObject* parent = nullptr);
+    Notifier(int fd, unsigned event_mask, Object* parent = nullptr);
 
     int m_fd { -1 };
     unsigned m_event_mask { 0 };
 };
+
+}
diff --git a/Libraries/LibCore/CObject.cpp b/Libraries/LibCore/CObject.cpp
index 4f8b7facc8..9bb1245628 100644
--- a/Libraries/LibCore/CObject.cpp
+++ b/Libraries/LibCore/CObject.cpp
@@ -32,13 +32,15 @@
 #include <LibCore/CObject.h>
 #include <stdio.h>
 
-IntrusiveList<CObject, &CObject::m_all_objects_list_node>& CObject::all_objects()
+namespace Core {
+
+IntrusiveList<Object, &Object::m_all_objects_list_node>& Object::all_objects()
 {
-    static IntrusiveList<CObject, &CObject::m_all_objects_list_node> objects;
+    static IntrusiveList<Object, &Object::m_all_objects_list_node> objects;
     return objects;
 }
 
-CObject::CObject(CObject* parent, bool is_widget)
+Object::Object(Object* parent, bool is_widget)
     : m_parent(parent)
     , m_widget(is_widget)
 {
@@ -47,7 +49,7 @@ CObject::CObject(CObject* parent, bool is_widget)
         m_parent->add_child(*this);
 }
 
-CObject::~CObject()
+Object::~Object()
 {
     // NOTE: We move our children out to a stack vector to prevent other
     //       code from trying to iterate over them.
@@ -63,89 +65,89 @@ CObject::~CObject()
         m_parent->remove_child(*this);
 }
 
-void CObject::event(CEvent& event)
+void Object::event(Core::Event& event)
 {
     switch (event.type()) {
-    case CEvent::Timer:
-        return timer_event(static_cast<CTimerEvent&>(event));
-    case CEvent::ChildAdded:
-    case CEvent::ChildRemoved:
-        return child_event(static_cast<CChildEvent&>(event));
-    case CEvent::Invalid:
+    case Core::Event::Timer:
+        return timer_event(static_cast<TimerEvent&>(event));
+    case Core::Event::ChildAdded:
+    case Core::Event::ChildRemoved:
+        return child_event(static_cast<ChildEvent&>(event));
+    case Core::Event::Invalid:
         ASSERT_NOT_REACHED();
         break;
-    case CEvent::Custom:
-        return custom_event(static_cast<CCustomEvent&>(event));
+    case Core::Event::Custom:
+        return custom_event(static_cast<CustomEvent&>(event));
     default:
         break;
     }
 }
 
-void CObject::add_child(CObject& object)
+void Object::add_child(Object& object)
 {
     // FIXME: Should we support reparenting objects?
     ASSERT(!object.parent() || object.parent() == this);
     object.m_parent = this;
     m_children.append(object);
-    event(*make<CChildEvent>(CEvent::ChildAdded, object));
+    event(*make<Core::ChildEvent>(Core::Event::ChildAdded, object));
 }
 
-void CObject::insert_child_before(CObject& new_child, CObject& before_child)
+void Object::insert_child_before(Object& new_child, Object& before_child)
 {
     // FIXME: Should we support reparenting objects?
     ASSERT(!new_child.parent() || new_child.parent() == this);
     new_child.m_parent = this;
     m_children.insert_before_matching(new_child, [&](auto& existing_child) { return existing_child.ptr() == &before_child; });
-    event(*make<CChildEvent>(CEvent::ChildAdded, new_child, &before_child));
+    event(*make<Core::ChildEvent>(Core::Event::ChildAdded, new_child, &before_child));
 }
 
-void CObject::remove_child(CObject& object)
+void Object::remove_child(Object& object)
 {
     for (int i = 0; i < m_children.size(); ++i) {
         if (m_children.ptr_at(i).ptr() == &object) {
             // NOTE: We protect the child so it survives the handling of ChildRemoved.
-            NonnullRefPtr<CObject> protector = object;
+            NonnullRefPtr<Object> protector = object;
             object.m_parent = nullptr;
             m_children.remove(i);
-            event(*make<CChildEvent>(CEvent::ChildRemoved, object));
+            event(*make<Core::ChildEvent>(Core::Event::ChildRemoved, object));
             return;
         }
     }
     ASSERT_NOT_REACHED();
 }
 
-void CObject::timer_event(CTimerEvent&)
+void Object::timer_event(Core::TimerEvent&)
 {
 }
 
-void CObject::child_event(CChildEvent&)
+void Object::child_event(Core::ChildEvent&)
 {
 }
 
-void CObject::custom_event(CCustomEvent&)
+void Object::custom_event(CustomEvent&)
 {
 }
 
-void CObject::start_timer(int ms, TimerShouldFireWhenNotVisible fire_when_not_visible)
+void Object::start_timer(int ms, TimerShouldFireWhenNotVisible fire_when_not_visible)
 {
     if (m_timer_id) {
-        dbgprintf("CObject{%p} already has a timer!\n", this);
+        dbgprintf("Object{%p} already has a timer!\n", this);
         ASSERT_NOT_REACHED();
     }
 
-    m_timer_id = CEventLoop::register_timer(*this, ms, true, fire_when_not_visible);
+    m_timer_id = Core::EventLoop::register_timer(*this, ms, true, fire_when_not_visible);
 }
 
-void CObject::stop_timer()
+void Object::stop_timer()
 {
     if (!m_timer_id)
         return;
-    bool success = CEventLoop::unregister_timer(m_timer_id);
+    bool success = Core::EventLoop::unregister_timer(m_timer_id);
     ASSERT(success);
     m_timer_id = 0;
 }
 
-void CObject::dump_tree(int indent)
+void Object::dump_tree(int indent)
 {
     for (int i = 0; i < indent; ++i) {
         printf(" ");
@@ -158,12 +160,12 @@ void CObject::dump_tree(int indent)
     });
 }
 
-void CObject::deferred_invoke(Function<void(CObject&)> invokee)
+void Object::deferred_invoke(Function<void(Object&)> invokee)
 {
-    CEventLoop::current().post_event(*this, make<CDeferredInvocationEvent>(move(invokee)));
+    Core::EventLoop::current().post_event(*this, make<Core::DeferredInvocationEvent>(move(invokee)));
 }
 
-void CObject::save_to(JsonObject& json)
+void Object::save_to(JsonObject& json)
 {
     json.set("class_name", class_name());
     json.set("address", String::format("%p", this));
@@ -171,7 +173,7 @@ void CObject::save_to(JsonObject& json)
     json.set("parent", String::format("%p", parent()));
 }
 
-bool CObject::is_ancestor_of(const CObject& other) const
+bool Object::is_ancestor_of(const Object& other) const
 {
     if (&other == this)
         return false;
@@ -182,7 +184,7 @@ bool CObject::is_ancestor_of(const CObject& other) const
     return false;
 }
 
-void CObject::dispatch_event(CEvent& e, CObject* stay_within)
+void Object::dispatch_event(Core::Event& e, Object* stay_within)
 {
     ASSERT(!stay_within || stay_within == this || stay_within->is_ancestor_of(*this));
     auto* target = this;
@@ -197,9 +199,11 @@ void CObject::dispatch_event(CEvent& e, CObject* stay_within)
     } while (target && !e.is_accepted());
 }
 
-bool CObject::is_visible_for_timer_purposes() const
+bool Object::is_visible_for_timer_purposes() const
 {
     if (parent())
         return parent()->is_visible_for_timer_purposes();
     return true;
 }
+
+}
diff --git a/Libraries/LibCore/CObject.h b/Libraries/LibCore/CObject.h
index df4ad4b815..bc86be1350 100644
--- a/Libraries/LibCore/CObject.h
+++ b/Libraries/LibCore/CObject.h
@@ -40,16 +40,18 @@ namespace AK {
 class JsonObject;
 }
 
+namespace Core {
+
 enum class TimerShouldFireWhenNotVisible {
     No = 0,
     Yes
 };
 
-class CEvent;
-class CEventLoop;
-class CChildEvent;
-class CCustomEvent;
-class CTimerEvent;
+class ChildEvent;
+class CustomEvent;
+class Event;
+class EventLoop;
+class TimerEvent;
 
 #define C_OBJECT(klass)                                                \
 public:                                                                \
@@ -64,26 +66,26 @@ public:                                                                \
 public:                          \
     virtual const char* class_name() const override { return #klass; }
 
-class CObject
-    : public RefCounted<CObject>
-    , public Weakable<CObject> {
-    // NOTE: No C_OBJECT macro for CObject itself.
+class Object
+    : public RefCounted<Object>
+    , public Weakable<Object> {
+    // NOTE: No C_OBJECT macro for Core::Object itself.
 
-    AK_MAKE_NONCOPYABLE(CObject)
-    AK_MAKE_NONMOVABLE(CObject)
+    AK_MAKE_NONCOPYABLE(Object)
+    AK_MAKE_NONMOVABLE(Object)
 public:
     IntrusiveListNode m_all_objects_list_node;
 
-    virtual ~CObject();
+    virtual ~Object();
 
     virtual const char* class_name() const = 0;
-    virtual void event(CEvent&);
+    virtual void event(Core::Event&);
 
     const String& name() const { return m_name; }
     void set_name(const StringView& name) { m_name = name; }
 
-    NonnullRefPtrVector<CObject>& children() { return m_children; }
-    const NonnullRefPtrVector<CObject>& children() const { return m_children; }
+    NonnullRefPtrVector<Object>& children() { return m_children; }
+    const NonnullRefPtrVector<Object>& children() const { return m_children; }
 
     template<typename Callback>
     void for_each_child(Callback callback)
@@ -97,22 +99,22 @@ public:
     template<typename T, typename Callback>
     void for_each_child_of_type(Callback callback);
 
-    bool is_ancestor_of(const CObject&) const;
+    bool is_ancestor_of(const Object&) const;
 
-    CObject* parent() { return m_parent; }
-    const CObject* parent() const { return m_parent; }
+    Object* parent() { return m_parent; }
+    const Object* parent() const { return m_parent; }
 
     void start_timer(int ms, TimerShouldFireWhenNotVisible = TimerShouldFireWhenNotVisible::No);
     void stop_timer();
     bool has_timer() const { return m_timer_id; }
 
-    void add_child(CObject&);
-    void insert_child_before(CObject& new_child, CObject& before_child);
-    void remove_child(CObject&);
+    void add_child(Object&);
+    void insert_child_before(Object& new_child, Object& before_child);
+    void remove_child(Object&);
 
     void dump_tree(int indent = 0);
 
-    void deferred_invoke(Function<void(CObject&)>);
+    void deferred_invoke(Function<void(Object&)>);
 
     bool is_widget() const { return m_widget; }
     virtual bool is_action() const { return false; }
@@ -120,9 +122,9 @@ public:
 
     virtual void save_to(AK::JsonObject&);
 
-    static IntrusiveList<CObject, &CObject::m_all_objects_list_node>& all_objects();
+    static IntrusiveList<Object, &Object::m_all_objects_list_node>& all_objects();
 
-    void dispatch_event(CEvent&, CObject* stay_within = nullptr);
+    void dispatch_event(Core::Event&, Object* stay_within = nullptr);
 
     void remove_from_parent()
     {
@@ -133,41 +135,41 @@ public:
     virtual bool is_visible_for_timer_purposes() const;
 
 protected:
-    explicit CObject(CObject* parent = nullptr, bool is_widget = false);
+    explicit Object(Object* parent = nullptr, bool is_widget = false);
 
-    virtual void timer_event(CTimerEvent&);
-    virtual void custom_event(CCustomEvent&);
+    virtual void timer_event(TimerEvent&);
+    virtual void custom_event(CustomEvent&);
 
     // NOTE: You may get child events for children that are not yet fully constructed!
-    virtual void child_event(CChildEvent&);
+    virtual void child_event(ChildEvent&);
 
 private:
-    CObject* m_parent { nullptr };
+    Object* m_parent { nullptr };
     String m_name;
     int m_timer_id { 0 };
     bool m_widget { false };
-    NonnullRefPtrVector<CObject> m_children;
+    NonnullRefPtrVector<Object> m_children;
 };
 
 template<typename T>
-inline bool is(const CObject&) { return false; }
+inline bool is(const Object&) { return false; }
 
 template<typename T>
-inline T& to(CObject& object)
+inline T& to(Object& object)
 {
     ASSERT(is<typename RemoveConst<T>::Type>(object));
     return static_cast<T&>(object);
 }
 
 template<typename T>
-inline const T& to(const CObject& object)
+inline const T& to(const Object& object)
 {
     ASSERT(is<typename RemoveConst<T>::Type>(object));
     return static_cast<const T&>(object);
 }
 
 template<typename T, typename Callback>
-inline void CObject::for_each_child_of_type(Callback callback)
+inline void Object::for_each_child_of_type(Callback callback)
 {
     for_each_child([&](auto& child) {
         if (is<T>(child))
@@ -176,7 +178,9 @@ inline void CObject::for_each_child_of_type(Callback callback)
     });
 }
 
-inline const LogStream& operator<<(const LogStream& stream, const CObject& object)
+inline const LogStream& operator<<(const LogStream& stream, const Object& object)
 {
     return stream << object.class_name() << '{' << &object << '}';
 }
+
+}
diff --git a/Libraries/LibCore/CProcessStatisticsReader.cpp b/Libraries/LibCore/CProcessStatisticsReader.cpp
index 51c237513a..815dc52f14 100644
--- a/Libraries/LibCore/CProcessStatisticsReader.cpp
+++ b/Libraries/LibCore/CProcessStatisticsReader.cpp
@@ -32,23 +32,25 @@
 #include <pwd.h>
 #include <stdio.h>
 
-HashMap<uid_t, String> CProcessStatisticsReader::s_usernames;
+namespace Core {
 
-HashMap<pid_t, CProcessStatistics> CProcessStatisticsReader::get_all()
+HashMap<uid_t, String> ProcessStatisticsReader::s_usernames;
+
+HashMap<pid_t, Core::ProcessStatistics> ProcessStatisticsReader::get_all()
 {
-    auto file = CFile::construct("/proc/all");
-    if (!file->open(CIODevice::ReadOnly)) {
+    auto file = Core::File::construct("/proc/all");
+    if (!file->open(Core::IODevice::ReadOnly)) {
         fprintf(stderr, "CProcessStatisticsReader: Failed to open /proc/all: %s\n", file->error_string());
         return {};
     }
 
-    HashMap<pid_t, CProcessStatistics> map;
+    HashMap<pid_t, Core::ProcessStatistics> map;
 
     auto file_contents = file->read_all();
     auto json = JsonValue::from_string({ file_contents.data(), (size_t)file_contents.size() });
     json.as_array().for_each([&](auto& value) {
         const JsonObject& process_object = value.as_object();
-        CProcessStatistics process;
+        Core::ProcessStatistics process;
 
         // kernel data first
         process.pid = process_object.get("pid").to_u32();
@@ -76,7 +78,7 @@ HashMap<pid_t, CProcessStatistics> CProcessStatisticsReader::get_all()
         process.threads.ensure_capacity(thread_array.size());
         thread_array.for_each([&](auto& value) {
             auto& thread_object = value.as_object();
-            CThreadStatistics thread;
+            Core::ThreadStatistics thread;
             thread.tid = thread_object.get("tid").to_u32();
             thread.times_scheduled = thread_object.get("times_scheduled").to_u32();
             thread.name = thread_object.get("name").to_string();
@@ -105,7 +107,7 @@ HashMap<pid_t, CProcessStatistics> CProcessStatisticsReader::get_all()
     return map;
 }
 
-String CProcessStatisticsReader::username_from_uid(uid_t uid)
+String ProcessStatisticsReader::username_from_uid(uid_t uid)
 {
     if (s_usernames.is_empty()) {
         setpwent();
@@ -119,3 +121,4 @@ String CProcessStatisticsReader::username_from_uid(uid_t uid)
         return (*it).value;
     return String::number(uid);
 }
+}
diff --git a/Libraries/LibCore/CProcessStatisticsReader.h b/Libraries/LibCore/CProcessStatisticsReader.h
index c5b7aaeb91..d0850f2d48 100644
--- a/Libraries/LibCore/CProcessStatisticsReader.h
+++ b/Libraries/LibCore/CProcessStatisticsReader.h
@@ -30,7 +30,9 @@
 #include <AK/String.h>
 #include <unistd.h>
 
-struct CThreadStatistics {
+namespace Core {
+
+struct ThreadStatistics {
     int tid;
     unsigned times_scheduled;
     unsigned ticks;
@@ -50,7 +52,7 @@ struct CThreadStatistics {
     String name;
 };
 
-struct CProcessStatistics {
+struct ProcessStatistics {
     // Keep this in sync with /proc/all.
     // From the kernel side:
     pid_t pid;
@@ -74,17 +76,19 @@ struct CProcessStatistics {
     size_t amount_purgeable_nonvolatile;
     int icon_id;
 
-    Vector<CThreadStatistics> threads;
+    Vector<Core::ThreadStatistics> threads;
 
     // synthetic
     String username;
 };
 
-class CProcessStatisticsReader {
+class ProcessStatisticsReader {
 public:
-    static HashMap<pid_t, CProcessStatistics> get_all();
+    static HashMap<pid_t, Core::ProcessStatistics> get_all();
 
 private:
     static String username_from_uid(uid_t);
     static HashMap<uid_t, String> s_usernames;
 };
+
+}
diff --git a/Libraries/LibCore/CSocket.cpp b/Libraries/LibCore/CSocket.cpp
index 135911b01c..e16ef730ea 100644
--- a/Libraries/LibCore/CSocket.cpp
+++ b/Libraries/LibCore/CSocket.cpp
@@ -38,33 +38,35 @@
 
 //#define CSOCKET_DEBUG
 
-CSocket::CSocket(Type type, CObject* parent)
-    : CIODevice(parent)
+namespace Core {
+
+Socket::Socket(Type type, Object* parent)
+    : IODevice(parent)
     , m_type(type)
 {
 }
 
-CSocket::~CSocket()
+Socket::~Socket()
 {
     close();
 }
 
-bool CSocket::connect(const String& hostname, int port)
+bool Socket::connect(const String& hostname, int port)
 {
     auto* hostent = gethostbyname(hostname.characters());
     if (!hostent) {
-        dbg() << "CSocket::connect: Unable to resolve '" << hostname << "'";
+        dbg() << "Socket::connect: Unable to resolve '" << hostname << "'";
         return false;
     }
 
     IPv4Address host_address((const u8*)hostent->h_addr_list[0]);
 #ifdef CSOCKET_DEBUG
-    dbg() << "CSocket::connect: Resolved '" << hostname << "' to " << host_address;
+    dbg() << "Socket::connect: Resolved '" << hostname << "' to " << host_address;
 #endif
     return connect(host_address, port);
 }
 
-void CSocket::set_blocking(bool blocking)
+void Socket::set_blocking(bool blocking)
 {
     int flags = fcntl(fd(), F_GETFL, 0);
     ASSERT(flags >= 0);
@@ -75,10 +77,10 @@ void CSocket::set_blocking(bool blocking)
     ASSERT(flags == 0);
 }
 
-bool CSocket::connect(const CSocketAddress& address, int port)
+bool Socket::connect(const SocketAddress& address, int port)
 {
     ASSERT(!is_connected());
-    ASSERT(address.type() == CSocketAddress::Type::IPv4);
+    ASSERT(address.type() == SocketAddress::Type::IPv4);
 #ifdef CSOCKET_DEBUG
     dbg() << *this << " connecting to " << address << "...";
 #endif
@@ -98,10 +100,10 @@ bool CSocket::connect(const CSocketAddress& address, int port)
     return common_connect((struct sockaddr*)&addr, sizeof(addr));
 }
 
-bool CSocket::connect(const CSocketAddress& address)
+bool Socket::connect(const SocketAddress& address)
 {
     ASSERT(!is_connected());
-    ASSERT(address.type() == CSocketAddress::Type::Local);
+    ASSERT(address.type() == SocketAddress::Type::Local);
 #ifdef CSOCKET_DEBUG
     dbg() << *this << " connecting to " << address << "...";
 #endif
@@ -113,7 +115,7 @@ bool CSocket::connect(const CSocketAddress& address)
     return common_connect((const sockaddr*)&saddr, sizeof(saddr));
 }
 
-bool CSocket::common_connect(const struct sockaddr* addr, socklen_t addrlen)
+bool Socket::common_connect(const struct sockaddr* addr, socklen_t addrlen)
 {
     int rc = ::connect(fd(), addr, addrlen);
     if (rc < 0) {
@@ -121,20 +123,20 @@ bool CSocket::common_connect(const struct sockaddr* addr, socklen_t addrlen)
 #ifdef CSOCKET_DEBUG
             dbg() << *this << " connection in progress (EINPROGRESS)";
 #endif
-            m_notifier = CNotifier::construct(fd(), CNotifier::Event::Write, this);
+            m_notifier = Notifier::construct(fd(), Notifier::Event::Write, this);
             m_notifier->on_ready_to_write = [this] {
 #ifdef CSOCKET_DEBUG
                 dbg() << *this << " connected!";
 #endif
                 m_connected = true;
                 ensure_read_notifier();
-                m_notifier->set_event_mask(CNotifier::Event::None);
+                m_notifier->set_event_mask(Notifier::Event::None);
                 if (on_connected)
                     on_connected();
             };
             return true;
         }
-        perror("CSocket::common_connect: connect");
+        perror("Socket::common_connect: connect");
         return false;
     }
 #ifdef CSOCKET_DEBUG
@@ -147,7 +149,7 @@ bool CSocket::common_connect(const struct sockaddr* addr, socklen_t addrlen)
     return true;
 }
 
-ByteBuffer CSocket::receive(int max_size)
+ByteBuffer Socket::receive(int max_size)
 {
     auto buffer = read(max_size);
     if (eof()) {
@@ -157,7 +159,7 @@ ByteBuffer CSocket::receive(int max_size)
     return buffer;
 }
 
-bool CSocket::send(const ByteBuffer& data)
+bool Socket::send(const ByteBuffer& data)
 {
     int nsent = ::send(fd(), data.data(), data.size(), 0);
     if (nsent < 0) {
@@ -168,7 +170,7 @@ bool CSocket::send(const ByteBuffer& data)
     return true;
 }
 
-void CSocket::did_update_fd(int fd)
+void Socket::did_update_fd(int fd)
 {
     if (fd < 0) {
         m_read_notifier = nullptr;
@@ -182,12 +184,14 @@ void CSocket::did_update_fd(int fd)
     }
 }
 
-void CSocket::ensure_read_notifier()
+void Socket::ensure_read_notifier()
 {
     ASSERT(m_connected);
-    m_read_notifier = CNotifier::construct(fd(), CNotifier::Event::Read, this);
+    m_read_notifier = Notifier::construct(fd(), Notifier::Event::Read, this);
     m_read_notifier->on_ready_to_read = [this] {
         if (on_ready_to_read)
             on_ready_to_read();
     };
 }
+
+}
diff --git a/Libraries/LibCore/CSocket.h b/Libraries/LibCore/CSocket.h
index afd78164b5..5538bbd2b8 100644
--- a/Libraries/LibCore/CSocket.h
+++ b/Libraries/LibCore/CSocket.h
@@ -29,10 +29,12 @@
 #include <LibCore/CIODevice.h>
 #include <LibCore/CSocketAddress.h>
 
-class CNotifier;
+namespace Core {
 
-class CSocket : public CIODevice {
-    C_OBJECT(CSocket)
+class Notifier;
+
+class Socket : public IODevice {
+    C_OBJECT(Socket)
 public:
     enum class Type {
         Invalid,
@@ -40,13 +42,13 @@ public:
         UDP,
         Local,
     };
-    virtual ~CSocket() override;
+    virtual ~Socket() override;
 
     Type type() const { return m_type; }
 
     bool connect(const String& hostname, int port);
-    bool connect(const CSocketAddress&, int port);
-    bool connect(const CSocketAddress&);
+    bool connect(const SocketAddress&, int port);
+    bool connect(const SocketAddress&);
 
     ByteBuffer receive(int max_size);
     bool send(const ByteBuffer&);
@@ -54,20 +56,20 @@ public:
     bool is_connected() const { return m_connected; }
     void set_blocking(bool blocking);
 
-    CSocketAddress source_address() const { return m_source_address; }
+    SocketAddress source_address() const { return m_source_address; }
     int source_port() const { return m_source_port; }
 
-    CSocketAddress destination_address() const { return m_source_address; }
+    SocketAddress destination_address() const { return m_source_address; }
     int destination_port() const { return m_destination_port; }
 
     Function<void()> on_connected;
     Function<void()> on_ready_to_read;
 
 protected:
-    CSocket(Type, CObject* parent);
+    Socket(Type, Object* parent);
 
-    CSocketAddress m_source_address;
-    CSocketAddress m_destination_address;
+    SocketAddress m_source_address;
+    SocketAddress m_destination_address;
     int m_source_port { -1 };
     int m_destination_port { -1 };
     bool m_connected { false };
@@ -75,11 +77,13 @@ protected:
     virtual void did_update_fd(int) override;
 
 private:
-    virtual bool open(CIODevice::OpenMode) override { ASSERT_NOT_REACHED(); }
+    virtual bool open(IODevice::OpenMode) override { ASSERT_NOT_REACHED(); }
     bool common_connect(const struct sockaddr*, socklen_t);
     void ensure_read_notifier();
 
     Type m_type { Type::Invalid };
-    RefPtr<CNotifier> m_notifier;
-    RefPtr<CNotifier> m_read_notifier;
+    RefPtr<Notifier> m_notifier;
+    RefPtr<Notifier> m_read_notifier;
 };
+
+}
diff --git a/Libraries/LibCore/CSocketAddress.h b/Libraries/LibCore/CSocketAddress.h
index b6486f11a1..3c0bfcf482 100644
--- a/Libraries/LibCore/CSocketAddress.h
+++ b/Libraries/LibCore/CSocketAddress.h
@@ -32,7 +32,9 @@
 #include <sys/socket.h>
 #include <sys/un.h>
 
-class CSocketAddress {
+namespace Core {
+
+class SocketAddress {
 public:
     enum class Type {
         Invalid,
@@ -40,23 +42,23 @@ public:
         Local
     };
 
-    CSocketAddress() {}
-    CSocketAddress(const IPv4Address& address)
+    SocketAddress() {}
+    SocketAddress(const IPv4Address& address)
         : m_type(Type::IPv4)
         , m_ipv4_address(address)
     {
     }
 
-    CSocketAddress(const IPv4Address& address, u16 port)
+    SocketAddress(const IPv4Address& address, u16 port)
         : m_type(Type::IPv4)
         , m_ipv4_address(address)
         , m_port(port)
     {
     }
 
-    static CSocketAddress local(const String& address)
+    static SocketAddress local(const String& address)
     {
-        CSocketAddress addr;
+        SocketAddress addr;
         addr.m_type = Type::Local;
         addr.m_local_address = address;
         return addr;
@@ -106,7 +108,9 @@ private:
     String m_local_address;
 };
 
-inline const LogStream& operator<<(const LogStream& stream, const CSocketAddress& value)
+inline const LogStream& operator<<(const LogStream& stream, const SocketAddress& value)
 {
     return stream << value.to_string();
 }
+
+}
diff --git a/Libraries/LibCore/CTCPServer.cpp b/Libraries/LibCore/CTCPServer.cpp
index d79eeb1909..4813d17d74 100644
--- a/Libraries/LibCore/CTCPServer.cpp
+++ b/Libraries/LibCore/CTCPServer.cpp
@@ -32,24 +32,26 @@
 #include <stdio.h>
 #include <sys/socket.h>
 
-CTCPServer::CTCPServer(CObject* parent)
-    : CObject(parent)
+namespace Core {
+
+TCPServer::TCPServer(Object* parent)
+    : Object(parent)
 {
     m_fd = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
     ASSERT(m_fd >= 0);
 }
 
-CTCPServer::~CTCPServer()
+TCPServer::~TCPServer()
 {
 }
 
-bool CTCPServer::listen(const IPv4Address& address, u16 port)
+bool TCPServer::listen(const IPv4Address& address, u16 port)
 {
     if (m_listening)
         return false;
 
     int rc;
-    auto socket_address = CSocketAddress(address, port);
+    auto socket_address = SocketAddress(address, port);
     auto in = socket_address.to_sockaddr_in();
     rc = ::bind(m_fd, (const sockaddr*)&in, sizeof(in));
     ASSERT(rc == 0);
@@ -58,7 +60,7 @@ bool CTCPServer::listen(const IPv4Address& address, u16 port)
     ASSERT(rc == 0);
     m_listening = true;
 
-    m_notifier = CNotifier::construct(m_fd, CNotifier::Event::Read);
+    m_notifier = Notifier::construct(m_fd, Notifier::Event::Read);
     m_notifier->on_ready_to_read = [this] {
         if (on_ready_to_accept)
             on_ready_to_accept();
@@ -66,7 +68,7 @@ bool CTCPServer::listen(const IPv4Address& address, u16 port)
     return true;
 }
 
-RefPtr<CTCPSocket> CTCPServer::accept()
+RefPtr<TCPSocket> TCPServer::accept()
 {
     ASSERT(m_listening);
     sockaddr_in in;
@@ -77,10 +79,10 @@ RefPtr<CTCPSocket> CTCPServer::accept()
         return nullptr;
     }
 
-    return CTCPSocket::construct(accepted_fd);
+    return TCPSocket::construct(accepted_fd);
 }
 
-Optional<IPv4Address> CTCPServer::local_address() const
+Optional<IPv4Address> TCPServer::local_address() const
 {
     if (m_fd == -1)
         return {};
@@ -93,7 +95,7 @@ Optional<IPv4Address> CTCPServer::local_address() const
     return IPv4Address(address.sin_addr.s_addr);
 }
 
-Optional<u16> CTCPServer::local_port() const
+Optional<u16> TCPServer::local_port() const
 {
     if (m_fd == -1)
         return {};
@@ -105,3 +107,5 @@ Optional<u16> CTCPServer::local_port() const
 
     return ntohs(address.sin_port);
 }
+
+}
diff --git a/Libraries/LibCore/CTCPServer.h b/Libraries/LibCore/CTCPServer.h
index b5222e0daa..de76f8c374 100644
--- a/Libraries/LibCore/CTCPServer.h
+++ b/Libraries/LibCore/CTCPServer.h
@@ -30,17 +30,19 @@
 #include <LibCore/CNotifier.h>
 #include <LibCore/CObject.h>
 
-class CTCPSocket;
+namespace Core {
 
-class CTCPServer : public CObject {
-    C_OBJECT(CTCPServer)
+class TCPSocket;
+
+class TCPServer : public Object {
+    C_OBJECT(TCPServer)
 public:
-    virtual ~CTCPServer() override;
+    virtual ~TCPServer() override;
 
     bool is_listening() const { return m_listening; }
     bool listen(const IPv4Address& address, u16 port);
 
-    RefPtr<CTCPSocket> accept();
+    RefPtr<TCPSocket> accept();
 
     Optional<IPv4Address> local_address() const;
     Optional<u16> local_port() const;
@@ -48,9 +50,11 @@ public:
     Function<void()> on_ready_to_accept;
 
 private:
-    explicit CTCPServer(CObject* parent = nullptr);
+    explicit TCPServer(Object* parent = nullptr);
 
     int m_fd { -1 };
     bool m_listening { false };
-    RefPtr<CNotifier> m_notifier;
+    RefPtr<Notifier> m_notifier;
 };
+
+}
diff --git a/Libraries/LibCore/CTCPSocket.cpp b/Libraries/LibCore/CTCPSocket.cpp
index 799ff495ca..cc47708438 100644
--- a/Libraries/LibCore/CTCPSocket.cpp
+++ b/Libraries/LibCore/CTCPSocket.cpp
@@ -25,32 +25,36 @@
  */
 
 #include <LibCore/CTCPSocket.h>
-#include <sys/socket.h>
 #include <errno.h>
+#include <sys/socket.h>
+
+namespace Core {
 
-CTCPSocket::CTCPSocket(int fd, CObject* parent)
-    : CSocket(CSocket::Type::TCP, parent)
+TCPSocket::TCPSocket(int fd, Object* parent)
+    : Socket(Socket::Type::TCP, parent)
 {
     // NOTE: This constructor is used by CTCPServer::accept(), so the socket is already connected.
     m_connected = true;
     set_fd(fd);
-    set_mode(CIODevice::ReadWrite);
+    set_mode(IODevice::ReadWrite);
     set_error(0);
 }
 
-CTCPSocket::CTCPSocket(CObject* parent)
-    : CSocket(CSocket::Type::TCP, parent)
+TCPSocket::TCPSocket(Object* parent)
+    : Socket(Socket::Type::TCP, parent)
 {
     int fd = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0);
     if (fd < 0) {
         set_error(errno);
     } else {
         set_fd(fd);
-        set_mode(CIODevice::ReadWrite);
+        set_mode(IODevice::ReadWrite);
         set_error(0);
     }
 }
 
-CTCPSocket::~CTCPSocket()
+TCPSocket::~TCPSocket()
 {
 }
+
+}
diff --git a/Libraries/LibCore/CTCPSocket.h b/Libraries/LibCore/CTCPSocket.h
index 29b174f366..e3168b3d8d 100644
--- a/Libraries/LibCore/CTCPSocket.h
+++ b/Libraries/LibCore/CTCPSocket.h
@@ -29,14 +29,18 @@
 #include <AK/Badge.h>
 #include <LibCore/CSocket.h>
 
-class CTCPServer;
+namespace Core {
 
-class CTCPSocket final : public CSocket {
-    C_OBJECT(CTCPSocket)
+class TCPServer;
+
+class TCPSocket final : public Socket {
+    C_OBJECT(TCPSocket)
 public:
-    virtual ~CTCPSocket() override;
+    virtual ~TCPSocket() override;
 
 private:
-    CTCPSocket(int fd, CObject* parent = nullptr);
-    explicit CTCPSocket(CObject* parent = nullptr);
+    TCPSocket(int fd, Object* parent = nullptr);
+    explicit TCPSocket(Object* parent = nullptr);
 };
+
+}
diff --git a/Libraries/LibCore/CTimer.cpp b/Libraries/LibCore/CTimer.cpp
index 113758e60d..40fdd38983 100644
--- a/Libraries/LibCore/CTimer.cpp
+++ b/Libraries/LibCore/CTimer.cpp
@@ -26,28 +26,30 @@
 
 #include <LibCore/CTimer.h>
 
-CTimer::CTimer(CObject* parent)
-    : CObject(parent)
+namespace Core {
+
+Timer::Timer(Object* parent)
+    : Object(parent)
 {
 }
 
-CTimer::CTimer(int interval, Function<void()>&& timeout_handler, CObject* parent)
-    : CObject(parent)
+Timer::Timer(int interval, Function<void()>&& timeout_handler, Object* parent)
+    : Object(parent)
     , on_timeout(move(timeout_handler))
 {
     start(interval);
 }
 
-CTimer::~CTimer()
+Timer::~Timer()
 {
 }
 
-void CTimer::start()
+void Timer::start()
 {
     start(m_interval);
 }
 
-void CTimer::start(int interval)
+void Timer::start(int interval)
 {
     if (m_active)
         return;
@@ -56,14 +58,14 @@ void CTimer::start(int interval)
     m_active = true;
 }
 
-void CTimer::restart(int interval)
+void Timer::restart(int interval)
 {
     if (m_active)
         stop();
     start(interval);
 }
 
-void CTimer::stop()
+void Timer::stop()
 {
     if (!m_active)
         return;
@@ -71,7 +73,7 @@ void CTimer::stop()
     m_active = false;
 }
 
-void CTimer::timer_event(CTimerEvent&)
+void Timer::timer_event(TimerEvent&)
 {
     if (m_single_shot)
         stop();
@@ -85,3 +87,5 @@ void CTimer::timer_event(CTimerEvent&)
     if (on_timeout)
         on_timeout();
 }
+
+}
diff --git a/Libraries/LibCore/CTimer.h b/Libraries/LibCore/CTimer.h
index 9b3c4056af..76b44773ff 100644
--- a/Libraries/LibCore/CTimer.h
+++ b/Libraries/LibCore/CTimer.h
@@ -29,10 +29,12 @@
 #include <AK/Function.h>
 #include <LibCore/CObject.h>
 
-class CTimer final : public CObject {
-    C_OBJECT(CTimer)
+namespace Core {
+
+class Timer final : public Object {
+    C_OBJECT(Timer)
 public:
-    virtual ~CTimer() override;
+    virtual ~Timer() override;
 
     void start();
     void start(int interval);
@@ -55,13 +57,15 @@ public:
     Function<void()> on_timeout;
 
 private:
-    explicit CTimer(CObject* parent = nullptr);
-    CTimer(int interval, Function<void()>&& timeout_handler, CObject* parent = nullptr);
+    explicit Timer(Object* parent = nullptr);
+    Timer(int interval, Function<void()>&& timeout_handler, Object* parent = nullptr);
 
-    virtual void timer_event(CTimerEvent&) override;
+    virtual void timer_event(TimerEvent&) override;
 
     bool m_active { false };
     bool m_single_shot { false };
     bool m_interval_dirty { false };
     int m_interval { 0 };
 };
+
+}
diff --git a/Libraries/LibCore/CUdpServer.cpp b/Libraries/LibCore/CUdpServer.cpp
index f843b71fc9..82c0c2b574 100644
--- a/Libraries/LibCore/CUdpServer.cpp
+++ b/Libraries/LibCore/CUdpServer.cpp
@@ -32,24 +32,26 @@
 #include <stdio.h>
 #include <sys/socket.h>
 
-CUdpServer::CUdpServer(CObject* parent)
-    : CObject(parent)
+namespace Core {
+
+UdpServer::UdpServer(Object* parent)
+    : Object(parent)
 {
     m_fd = socket(AF_INET, SOCK_DGRAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
     ASSERT(m_fd >= 0);
 }
 
-CUdpServer::~CUdpServer()
+UdpServer::~UdpServer()
 {
 }
 
-bool CUdpServer::listen(const IPv4Address& address, u16 port)
+bool UdpServer::listen(const IPv4Address& address, u16 port)
 {
     if (m_listening)
         return false;
 
     int rc;
-    auto socket_address = CSocketAddress(address, port);
+    auto socket_address = SocketAddress(address, port);
     auto in = socket_address.to_sockaddr_in();
     rc = ::bind(m_fd, (const sockaddr*)&in, sizeof(in));
     ASSERT(rc == 0);
@@ -58,7 +60,7 @@ bool CUdpServer::listen(const IPv4Address& address, u16 port)
     ASSERT(rc == 0);
     m_listening = true;
 
-    m_notifier = CNotifier::construct(m_fd, CNotifier::Event::Read);
+    m_notifier = Notifier::construct(m_fd, Notifier::Event::Read);
     m_notifier->on_ready_to_read = [this] {
         if (on_ready_to_accept)
             on_ready_to_accept();
@@ -66,7 +68,7 @@ bool CUdpServer::listen(const IPv4Address& address, u16 port)
     return true;
 }
 
-RefPtr<CUdpSocket> CUdpServer::accept()
+RefPtr<UdpSocket> UdpServer::accept()
 {
     ASSERT(m_listening);
     sockaddr_in in;
@@ -77,10 +79,10 @@ RefPtr<CUdpSocket> CUdpServer::accept()
         return nullptr;
     }
 
-    return CUdpSocket::construct(accepted_fd);
+    return UdpSocket::construct(accepted_fd);
 }
 
-Optional<IPv4Address> CUdpServer::local_address() const
+Optional<IPv4Address> UdpServer::local_address() const
 {
     if (m_fd == -1)
         return {};
@@ -93,7 +95,7 @@ Optional<IPv4Address> CUdpServer::local_address() const
     return IPv4Address(address.sin_addr.s_addr);
 }
 
-Optional<u16> CUdpServer::local_port() const
+Optional<u16> UdpServer::local_port() const
 {
     if (m_fd == -1)
         return {};
@@ -105,3 +107,5 @@ Optional<u16> CUdpServer::local_port() const
 
     return ntohs(address.sin_port);
 }
+
+}
diff --git a/Libraries/LibCore/CUdpServer.h b/Libraries/LibCore/CUdpServer.h
index 80b2f539be..99836304a8 100644
--- a/Libraries/LibCore/CUdpServer.h
+++ b/Libraries/LibCore/CUdpServer.h
@@ -30,17 +30,19 @@
 #include <LibCore/CNotifier.h>
 #include <LibCore/CObject.h>
 
-class CUdpSocket;
+namespace Core {
 
-class CUdpServer : public CObject {
-    C_OBJECT(CUdpServer)
+class UdpSocket;
+
+class UdpServer : public Object {
+    C_OBJECT(UdpServer)
 public:
-    virtual ~CUdpServer() override;
+    virtual ~UdpServer() override;
 
     bool is_listening() const { return m_listening; }
     bool listen(const IPv4Address& address, u16 port);
 
-    RefPtr<CUdpSocket> accept();
+    RefPtr<UdpSocket> accept();
 
     Optional<IPv4Address> local_address() const;
     Optional<u16> local_port() const;
@@ -48,9 +50,11 @@ public:
     Function<void()> on_ready_to_accept;
 
 private:
-    explicit CUdpServer(CObject* parent = nullptr);
+    explicit UdpServer(Object* parent = nullptr);
 
     int m_fd { -1 };
     bool m_listening { false };
-    RefPtr<CNotifier> m_notifier;
+    RefPtr<Notifier> m_notifier;
 };
+
+}
diff --git a/Libraries/LibCore/CUdpSocket.cpp b/Libraries/LibCore/CUdpSocket.cpp
index a48a9f03bf..95490b51db 100644
--- a/Libraries/LibCore/CUdpSocket.cpp
+++ b/Libraries/LibCore/CUdpSocket.cpp
@@ -25,32 +25,36 @@
  */
 
 #include <LibCore/CUdpSocket.h>
-#include <sys/socket.h>
 #include <errno.h>
+#include <sys/socket.h>
+
+namespace Core {
 
-CUdpSocket::CUdpSocket(int fd, CObject* parent)
-    : CSocket(CSocket::Type::UDP, parent)
+UdpSocket::UdpSocket(int fd, Object* parent)
+    : Socket(Socket::Type::UDP, parent)
 {
     // NOTE: This constructor is used by CUdpServer::accept(), so the socket is already connected.
     m_connected = true;
     set_fd(fd);
-    set_mode(CIODevice::ReadWrite);
+    set_mode(IODevice::ReadWrite);
     set_error(0);
 }
 
-CUdpSocket::CUdpSocket(CObject* parent)
-    : CSocket(CSocket::Type::UDP, parent)
+UdpSocket::UdpSocket(Object* parent)
+    : Socket(Socket::Type::UDP, parent)
 {
     int fd = socket(AF_INET, SOCK_DGRAM | SOCK_NONBLOCK, 0);
     if (fd < 0) {
         set_error(errno);
     } else {
         set_fd(fd);
-        set_mode(CIODevice::ReadWrite);
+        set_mode(IODevice::ReadWrite);
         set_error(0);
     }
 }
 
-CUdpSocket::~CUdpSocket()
+UdpSocket::~UdpSocket()
 {
 }
+
+}
diff --git a/Libraries/LibCore/CUdpSocket.h b/Libraries/LibCore/CUdpSocket.h
index e3324d0281..759e93fb18 100644
--- a/Libraries/LibCore/CUdpSocket.h
+++ b/Libraries/LibCore/CUdpSocket.h
@@ -29,12 +29,16 @@
 #include <AK/Badge.h>
 #include <LibCore/CSocket.h>
 
-class CUdpSocket final : public CSocket {
-    C_OBJECT(CUdpSocket)
+namespace Core {
+
+class UdpSocket final : public Socket {
+    C_OBJECT(UdpSocket)
 public:
-    virtual ~CUdpSocket() override;
+    virtual ~UdpSocket() override;
 
 private:
-    CUdpSocket(int fd, CObject* parent = nullptr);
-    explicit CUdpSocket(CObject* parent = nullptr);
+    UdpSocket(int fd, Object* parent = nullptr);
+    explicit UdpSocket(Object* parent = nullptr);
 };
+
+}
diff --git a/Libraries/LibDraw/SystemTheme.cpp b/Libraries/LibDraw/SystemTheme.cpp
index 88437cea45..12538fb820 100644
--- a/Libraries/LibDraw/SystemTheme.cpp
+++ b/Libraries/LibDraw/SystemTheme.cpp
@@ -51,7 +51,7 @@ void set_system_theme(SharedBuffer& buffer)
 
 RefPtr<SharedBuffer> load_system_theme(const String& path)
 {
-    auto file = CConfigFile::open(path);
+    auto file = Core::ConfigFile::open(path);
     auto buffer = SharedBuffer::create_with_size(sizeof(SystemTheme));
 
     auto* data = (SystemTheme*)buffer->data();
diff --git a/Libraries/LibGUI/GAboutDialog.cpp b/Libraries/LibGUI/GAboutDialog.cpp
index 37878d5e3c..8abdc56fb2 100644
--- a/Libraries/LibGUI/GAboutDialog.cpp
+++ b/Libraries/LibGUI/GAboutDialog.cpp
@@ -30,7 +30,7 @@
 #include <LibGUI/GLabel.h>
 #include <LibGUI/GWidget.h>
 
-GAboutDialog::GAboutDialog(const StringView& name, const GraphicsBitmap* icon, CObject* parent)
+GAboutDialog::GAboutDialog(const StringView& name, const GraphicsBitmap* icon, Core::Object* parent)
     : GDialog(parent)
     , m_name(name)
     , m_icon(icon)
diff --git a/Libraries/LibGUI/GAboutDialog.h b/Libraries/LibGUI/GAboutDialog.h
index cef8074c5f..e355d0355e 100644
--- a/Libraries/LibGUI/GAboutDialog.h
+++ b/Libraries/LibGUI/GAboutDialog.h
@@ -33,14 +33,14 @@ class GAboutDialog final : public GDialog {
 public:
     virtual ~GAboutDialog() override;
 
-    static void show(const StringView& name, const GraphicsBitmap* icon = nullptr, CObject* parent = nullptr)
+    static void show(const StringView& name, const GraphicsBitmap* icon = nullptr, Core::Object* parent = nullptr)
     {
         auto dialog = GAboutDialog::construct(name, icon, parent);
         dialog->exec();
     }
 
 private:
-    GAboutDialog(const StringView& name, const GraphicsBitmap* icon = nullptr, CObject* parent = nullptr);
+    GAboutDialog(const StringView& name, const GraphicsBitmap* icon = nullptr, Core::Object* parent = nullptr);
 
     String m_name;
     RefPtr<GraphicsBitmap> m_icon;
diff --git a/Libraries/LibGUI/GAbstractButton.cpp b/Libraries/LibGUI/GAbstractButton.cpp
index 23f42ec7b3..68bd12fb84 100644
--- a/Libraries/LibGUI/GAbstractButton.cpp
+++ b/Libraries/LibGUI/GAbstractButton.cpp
@@ -37,7 +37,7 @@ GAbstractButton::GAbstractButton(const StringView& text, GWidget* parent)
     : GWidget(parent)
     , m_text(text)
 {
-    m_auto_repeat_timer = CTimer::construct(this);
+    m_auto_repeat_timer = Core::Timer::construct(this);
     m_auto_repeat_timer->on_timeout = [this] {
         click();
     };
@@ -147,13 +147,13 @@ void GAbstractButton::mouseup_event(GMouseEvent& event)
     GWidget::mouseup_event(event);
 }
 
-void GAbstractButton::enter_event(CEvent&)
+void GAbstractButton::enter_event(Core::Event&)
 {
     m_hovered = true;
     update();
 }
 
-void GAbstractButton::leave_event(CEvent&)
+void GAbstractButton::leave_event(Core::Event&)
 {
     m_hovered = false;
     update();
diff --git a/Libraries/LibGUI/GAbstractButton.h b/Libraries/LibGUI/GAbstractButton.h
index 9cd09c33bf..2b868b0b9d 100644
--- a/Libraries/LibGUI/GAbstractButton.h
+++ b/Libraries/LibGUI/GAbstractButton.h
@@ -33,7 +33,7 @@
 class GPainter;
 
 class GAbstractButton : public GWidget {
-    C_OBJECT(GAbstractButton)
+    C_OBJECT_ABSTRACT(GAbstractButton)
 public:
     virtual ~GAbstractButton() override;
 
@@ -69,8 +69,8 @@ protected:
     virtual void mousemove_event(GMouseEvent&) override;
     virtual void mouseup_event(GMouseEvent&) override;
     virtual void keydown_event(GKeyEvent&) override;
-    virtual void enter_event(CEvent&) override;
-    virtual void leave_event(CEvent&) override;
+    virtual void enter_event(Core::Event&) override;
+    virtual void leave_event(Core::Event&) override;
     virtual void change_event(GEvent&) override;
 
     void paint_text(GPainter&, const Rect&, const Font&, TextAlignment);
@@ -86,11 +86,11 @@ private:
     bool m_exclusive { false };
 
     int m_auto_repeat_interval { 0 };
-    RefPtr<CTimer> m_auto_repeat_timer;
+    RefPtr<Core::Timer> m_auto_repeat_timer;
 };
 
 template<>
-inline bool is<GAbstractButton>(const CObject& object)
+inline bool Core::is<GAbstractButton>(const Core::Object& object)
 {
     if (!is<GWidget>(object))
         return false;
diff --git a/Libraries/LibGUI/GAbstractTableView.cpp b/Libraries/LibGUI/GAbstractTableView.cpp
index a018813773..8dba874668 100644
--- a/Libraries/LibGUI/GAbstractTableView.cpp
+++ b/Libraries/LibGUI/GAbstractTableView.cpp
@@ -517,7 +517,7 @@ void GAbstractTableView::context_menu_event(GContextMenuEvent& event)
         on_context_menu_request(index, event);
 }
 
-void GAbstractTableView::leave_event(CEvent&)
+void GAbstractTableView::leave_event(Core::Event&)
 {
     window()->set_override_cursor(GStandardCursor::None);
     set_hovered_header_index(-1);
diff --git a/Libraries/LibGUI/GAbstractTableView.h b/Libraries/LibGUI/GAbstractTableView.h
index 719583a8e1..a40b155730 100644
--- a/Libraries/LibGUI/GAbstractTableView.h
+++ b/Libraries/LibGUI/GAbstractTableView.h
@@ -81,7 +81,7 @@ protected:
     virtual void mousemove_event(GMouseEvent&) override;
     virtual void doubleclick_event(GMouseEvent&) override;
     virtual void keydown_event(GKeyEvent&) override;
-    virtual void leave_event(CEvent&) override;
+    virtual void leave_event(Core::Event&) override;
     virtual void context_menu_event(GContextMenuEvent&) override;
 
     virtual void toggle_index(const GModelIndex&) {}
diff --git a/Libraries/LibGUI/GAction.cpp b/Libraries/LibGUI/GAction.cpp
index 86468761a6..b7f0833f66 100644
--- a/Libraries/LibGUI/GAction.cpp
+++ b/Libraries/LibGUI/GAction.cpp
@@ -32,52 +32,52 @@
 
 namespace GCommonActions {
 
-NonnullRefPtr<GAction> make_open_action(Function<void(GAction&)> callback, CObject* parent)
+NonnullRefPtr<GAction> make_open_action(Function<void(GAction&)> callback, Core::Object* parent)
 {
     return GAction::create("Open...", { Mod_Ctrl, Key_O }, GraphicsBitmap::load_from_file("/res/icons/16x16/open.png"), move(callback), parent);
 }
 
-NonnullRefPtr<GAction> make_move_to_front_action(Function<void(GAction&)> callback, CObject* parent)
+NonnullRefPtr<GAction> make_move_to_front_action(Function<void(GAction&)> callback, Core::Object* parent)
 {
     return GAction::create("Move to front", { Mod_Ctrl | Mod_Shift, Key_Up }, GraphicsBitmap::load_from_file("/res/icons/16x16/move-to-front.png"), move(callback), parent);
 }
 
-NonnullRefPtr<GAction> make_move_to_back_action(Function<void(GAction&)> callback, CObject* parent)
+NonnullRefPtr<GAction> make_move_to_back_action(Function<void(GAction&)> callback, Core::Object* parent)
 {
     return GAction::create("Move to back", { Mod_Ctrl | Mod_Shift, Key_Down }, GraphicsBitmap::load_from_file("/res/icons/16x16/move-to-back.png"), move(callback), parent);
 }
 
-NonnullRefPtr<GAction> make_undo_action(Function<void(GAction&)> callback, CObject* parent)
+NonnullRefPtr<GAction> make_undo_action(Function<void(GAction&)> callback, Core::Object* parent)
 {
     return GAction::create("Undo", { Mod_Ctrl, Key_Z }, GraphicsBitmap::load_from_file("/res/icons/16x16/undo.png"), move(callback), parent);
 }
 
-NonnullRefPtr<GAction> make_redo_action(Function<void(GAction&)> callback, CObject* parent)
+NonnullRefPtr<GAction> make_redo_action(Function<void(GAction&)> callback, Core::Object* parent)
 {
     return GAction::create("Redo", { Mod_Ctrl, Key_Y }, GraphicsBitmap::load_from_file("/res/icons/16x16/redo.png"), move(callback), parent);
 }
 
-NonnullRefPtr<GAction> make_delete_action(Function<void(GAction&)> callback, CObject* parent)
+NonnullRefPtr<GAction> make_delete_action(Function<void(GAction&)> callback, Core::Object* parent)
 {
     return GAction::create("Delete", { Mod_None, Key_Delete }, GraphicsBitmap::load_from_file("/res/icons/16x16/delete.png"), move(callback), parent);
 }
 
-NonnullRefPtr<GAction> make_cut_action(Function<void(GAction&)> callback, CObject* parent)
+NonnullRefPtr<GAction> make_cut_action(Function<void(GAction&)> callback, Core::Object* parent)
 {
     return GAction::create("Cut", { Mod_Ctrl, Key_X }, GraphicsBitmap::load_from_file("/res/icons/cut16.png"), move(callback), parent);
 }
 
-NonnullRefPtr<GAction> make_copy_action(Function<void(GAction&)> callback, CObject* parent)
+NonnullRefPtr<GAction> make_copy_action(Function<void(GAction&)> callback, Core::Object* parent)
 {
     return GAction::create("Copy", { Mod_Ctrl, Key_C }, GraphicsBitmap::load_from_file("/res/icons/16x16/edit-copy.png"), move(callback), parent);
 }
 
-NonnullRefPtr<GAction> make_paste_action(Function<void(GAction&)> callback, CObject* parent)
+NonnullRefPtr<GAction> make_paste_action(Function<void(GAction&)> callback, Core::Object* parent)
 {
     return GAction::create("Paste", { Mod_Ctrl, Key_V }, GraphicsBitmap::load_from_file("/res/icons/paste16.png"), move(callback), parent);
 }
 
-NonnullRefPtr<GAction> make_fullscreen_action(Function<void(GAction&)> callback, CObject* parent)
+NonnullRefPtr<GAction> make_fullscreen_action(Function<void(GAction&)> callback, Core::Object* parent)
 {
     return GAction::create("Fullscreen", { Mod_None, Key_F11 }, move(callback), parent);
 }
@@ -87,58 +87,58 @@ NonnullRefPtr<GAction> make_quit_action(Function<void(GAction&)> callback)
     return GAction::create("Quit", { Mod_Alt, Key_F4 }, move(callback));
 }
 
-NonnullRefPtr<GAction> make_go_back_action(Function<void(GAction&)> callback, CObject* parent)
+NonnullRefPtr<GAction> make_go_back_action(Function<void(GAction&)> callback, Core::Object* parent)
 {
     return GAction::create("Go back", { Mod_Alt, Key_Left }, GraphicsBitmap::load_from_file("/res/icons/16x16/go-back.png"), move(callback), parent);
 }
 
-NonnullRefPtr<GAction> make_go_forward_action(Function<void(GAction&)> callback, CObject* parent)
+NonnullRefPtr<GAction> make_go_forward_action(Function<void(GAction&)> callback, Core::Object* parent)
 {
     return GAction::create("Go forward", { Mod_Alt, Key_Right }, GraphicsBitmap::load_from_file("/res/icons/16x16/go-forward.png"), move(callback), parent);
 }
 
-NonnullRefPtr<GAction> make_go_home_action(Function<void(GAction&)> callback, CObject* parent)
+NonnullRefPtr<GAction> make_go_home_action(Function<void(GAction&)> callback, Core::Object* parent)
 {
     return GAction::create("Go home", { Mod_Alt, Key_Home }, GraphicsBitmap::load_from_file("/res/icons/16x16/go-home.png"), move(callback), parent);
 }
 
-NonnullRefPtr<GAction> make_reload_action(Function<void(GAction&)> callback, CObject* parent)
+NonnullRefPtr<GAction> make_reload_action(Function<void(GAction&)> callback, Core::Object* parent)
 {
     return GAction::create("Reload", { Mod_Ctrl, Key_R }, GraphicsBitmap::load_from_file("/res/icons/16x16/reload.png"), move(callback), parent);
 }
 
 }
 
-GAction::GAction(const StringView& text, Function<void(GAction&)> on_activation_callback, CObject* parent)
-    : CObject(parent)
+GAction::GAction(const StringView& text, Function<void(GAction&)> on_activation_callback, Core::Object* parent)
+    : Core::Object(parent)
     , on_activation(move(on_activation_callback))
     , m_text(text)
 {
 }
 
-GAction::GAction(const StringView& text, RefPtr<GraphicsBitmap>&& icon, Function<void(GAction&)> on_activation_callback, CObject* parent)
-    : CObject(parent)
+GAction::GAction(const StringView& text, RefPtr<GraphicsBitmap>&& icon, Function<void(GAction&)> on_activation_callback, Core::Object* parent)
+    : Core::Object(parent)
     , on_activation(move(on_activation_callback))
     , m_text(text)
     , m_icon(move(icon))
 {
 }
 
-GAction::GAction(const StringView& text, const GShortcut& shortcut, Function<void(GAction&)> on_activation_callback, CObject* parent)
+GAction::GAction(const StringView& text, const GShortcut& shortcut, Function<void(GAction&)> on_activation_callback, Core::Object* parent)
     : GAction(text, shortcut, nullptr, move(on_activation_callback), parent)
 {
 }
 
-GAction::GAction(const StringView& text, const GShortcut& shortcut, RefPtr<GraphicsBitmap>&& icon, Function<void(GAction&)> on_activation_callback, CObject* parent)
-    : CObject(parent)
+GAction::GAction(const StringView& text, const GShortcut& shortcut, RefPtr<GraphicsBitmap>&& icon, Function<void(GAction&)> on_activation_callback, Core::Object* parent)
+    : Core::Object(parent)
     , on_activation(move(on_activation_callback))
     , m_text(text)
     , m_icon(move(icon))
     , m_shortcut(shortcut)
 {
-    if (parent && is<GWidget>(*parent)) {
+    if (parent && Core::is<GWidget>(*parent)) {
         m_scope = ShortcutScope::WidgetLocal;
-    } else if (parent && is<GWindow>(*parent)) {
+    } else if (parent && Core::is<GWindow>(*parent)) {
         m_scope = ShortcutScope::WindowLocal;
     } else {
         m_scope = ShortcutScope::ApplicationGlobal;
@@ -152,7 +152,7 @@ GAction::~GAction()
         GApplication::the().unregister_global_shortcut_action({}, *this);
 }
 
-void GAction::activate(CObject* activator)
+void GAction::activate(Core::Object* activator)
 {
     if (activator)
         m_activator = activator->make_weak_ptr();
diff --git a/Libraries/LibGUI/GAction.h b/Libraries/LibGUI/GAction.h
index 31827f66d0..e9c9ddc608 100644
--- a/Libraries/LibGUI/GAction.h
+++ b/Libraries/LibGUI/GAction.h
@@ -44,24 +44,24 @@ class GButton;
 class GMenuItem;
 
 namespace GCommonActions {
-NonnullRefPtr<GAction> make_open_action(Function<void(GAction&)>, CObject* parent = nullptr);
-NonnullRefPtr<GAction> make_undo_action(Function<void(GAction&)>, CObject* parent = nullptr);
-NonnullRefPtr<GAction> make_redo_action(Function<void(GAction&)>, CObject* parent = nullptr);
-NonnullRefPtr<GAction> make_cut_action(Function<void(GAction&)>, CObject* parent = nullptr);
-NonnullRefPtr<GAction> make_copy_action(Function<void(GAction&)>, CObject* parent = nullptr);
-NonnullRefPtr<GAction> make_paste_action(Function<void(GAction&)>, CObject* parent = nullptr);
-NonnullRefPtr<GAction> make_delete_action(Function<void(GAction&)>, CObject* parent = nullptr);
-NonnullRefPtr<GAction> make_move_to_front_action(Function<void(GAction&)>, CObject* parent = nullptr);
-NonnullRefPtr<GAction> make_move_to_back_action(Function<void(GAction&)>, CObject* parent = nullptr);
-NonnullRefPtr<GAction> make_fullscreen_action(Function<void(GAction&)>, CObject* parent = nullptr);
+NonnullRefPtr<GAction> make_open_action(Function<void(GAction&)>, Core::Object* parent = nullptr);
+NonnullRefPtr<GAction> make_undo_action(Function<void(GAction&)>, Core::Object* parent = nullptr);
+NonnullRefPtr<GAction> make_redo_action(Function<void(GAction&)>, Core::Object* parent = nullptr);
+NonnullRefPtr<GAction> make_cut_action(Function<void(GAction&)>, Core::Object* parent = nullptr);
+NonnullRefPtr<GAction> make_copy_action(Function<void(GAction&)>, Core::Object* parent = nullptr);
+NonnullRefPtr<GAction> make_paste_action(Function<void(GAction&)>, Core::Object* parent = nullptr);
+NonnullRefPtr<GAction> make_delete_action(Function<void(GAction&)>, Core::Object* parent = nullptr);
+NonnullRefPtr<GAction> make_move_to_front_action(Function<void(GAction&)>, Core::Object* parent = nullptr);
+NonnullRefPtr<GAction> make_move_to_back_action(Function<void(GAction&)>, Core::Object* parent = nullptr);
+NonnullRefPtr<GAction> make_fullscreen_action(Function<void(GAction&)>, Core::Object* parent = nullptr);
 NonnullRefPtr<GAction> make_quit_action(Function<void(GAction&)>);
-NonnullRefPtr<GAction> make_go_back_action(Function<void(GAction&)>, CObject* parent = nullptr);
-NonnullRefPtr<GAction> make_go_forward_action(Function<void(GAction&)>, CObject* parent = nullptr);
-NonnullRefPtr<GAction> make_go_home_action(Function<void(GAction&)> callback, CObject* parent = nullptr);
-NonnullRefPtr<GAction> make_reload_action(Function<void(GAction&)>, CObject* parent = nullptr);
+NonnullRefPtr<GAction> make_go_back_action(Function<void(GAction&)>, Core::Object* parent = nullptr);
+NonnullRefPtr<GAction> make_go_forward_action(Function<void(GAction&)>, Core::Object* parent = nullptr);
+NonnullRefPtr<GAction> make_go_home_action(Function<void(GAction&)> callback, Core::Object* parent = nullptr);
+NonnullRefPtr<GAction> make_reload_action(Function<void(GAction&)>, Core::Object* parent = nullptr);
 };
 
-class GAction final : public CObject {
+class GAction final : public Core::Object {
     C_OBJECT(GAction)
 public:
     enum class ShortcutScope {
@@ -70,19 +70,19 @@ public:
         WindowLocal,
         ApplicationGlobal,
     };
-    static NonnullRefPtr<GAction> create(const StringView& text, Function<void(GAction&)> callback, CObject* parent = nullptr)
+    static NonnullRefPtr<GAction> create(const StringView& text, Function<void(GAction&)> callback, Core::Object* parent = nullptr)
     {
         return adopt(*new GAction(text, move(callback), parent));
     }
-    static NonnullRefPtr<GAction> create(const StringView& text, RefPtr<GraphicsBitmap>&& icon, Function<void(GAction&)> callback, CObject* parent = nullptr)
+    static NonnullRefPtr<GAction> create(const StringView& text, RefPtr<GraphicsBitmap>&& icon, Function<void(GAction&)> callback, Core::Object* parent = nullptr)
     {
         return adopt(*new GAction(text, move(icon), move(callback), parent));
     }
-    static NonnullRefPtr<GAction> create(const StringView& text, const GShortcut& shortcut, Function<void(GAction&)> callback, CObject* parent = nullptr)
+    static NonnullRefPtr<GAction> create(const StringView& text, const GShortcut& shortcut, Function<void(GAction&)> callback, Core::Object* parent = nullptr)
     {
         return adopt(*new GAction(text, shortcut, move(callback), parent));
     }
-    static NonnullRefPtr<GAction> create(const StringView& text, const GShortcut& shortcut, RefPtr<GraphicsBitmap>&& icon, Function<void(GAction&)> callback, CObject* parent = nullptr)
+    static NonnullRefPtr<GAction> create(const StringView& text, const GShortcut& shortcut, RefPtr<GraphicsBitmap>&& icon, Function<void(GAction&)> callback, Core::Object* parent = nullptr)
     {
         return adopt(*new GAction(text, shortcut, move(icon), move(callback), parent));
     }
@@ -93,12 +93,12 @@ public:
     const GraphicsBitmap* icon() const { return m_icon.ptr(); }
     void set_icon(const GraphicsBitmap* icon) { m_icon = icon; }
 
-    const CObject* activator() const { return m_activator.ptr(); }
-    CObject* activator() { return m_activator.ptr(); }
+    const Core::Object* activator() const { return m_activator.ptr(); }
+    Core::Object* activator() { return m_activator.ptr(); }
 
     Function<void(GAction&)> on_activation;
 
-    void activate(CObject* activator = nullptr);
+    void activate(Core::Object* activator = nullptr);
 
     bool is_enabled() const { return m_enabled; }
     void set_enabled(bool);
@@ -124,10 +124,10 @@ public:
 private:
     virtual bool is_action() const override { return true; }
 
-    GAction(const StringView& text, Function<void(GAction&)> = nullptr, CObject* = nullptr);
-    GAction(const StringView& text, const GShortcut&, Function<void(GAction&)> = nullptr, CObject* = nullptr);
-    GAction(const StringView& text, const GShortcut&, RefPtr<GraphicsBitmap>&& icon, Function<void(GAction&)> = nullptr, CObject* = nullptr);
-    GAction(const StringView& text, RefPtr<GraphicsBitmap>&& icon, Function<void(GAction&)> = nullptr, CObject* = nullptr);
+    GAction(const StringView& text, Function<void(GAction&)> = nullptr, Core::Object* = nullptr);
+    GAction(const StringView& text, const GShortcut&, Function<void(GAction&)> = nullptr, Core::Object* = nullptr);
+    GAction(const StringView& text, const GShortcut&, RefPtr<GraphicsBitmap>&& icon, Function<void(GAction&)> = nullptr, Core::Object* = nullptr);
+    GAction(const StringView& text, RefPtr<GraphicsBitmap>&& icon, Function<void(GAction&)> = nullptr, Core::Object* = nullptr);
 
     template<typename Callback>
     void for_each_toolbar_button(Callback);
@@ -145,11 +145,11 @@ private:
     HashTable<GButton*> m_buttons;
     HashTable<GMenuItem*> m_menu_items;
     WeakPtr<GActionGroup> m_action_group;
-    WeakPtr<CObject> m_activator;
+    WeakPtr<Core::Object> m_activator;
 };
 
 template<>
-inline bool is<GAction>(const CObject& object)
+inline bool Core::is<GAction>(const Core::Object& object)
 {
     return object.is_action();
 }
diff --git a/Libraries/LibGUI/GApplication.cpp b/Libraries/LibGUI/GApplication.cpp
index 4343bd639c..893a952dfe 100644
--- a/Libraries/LibGUI/GApplication.cpp
+++ b/Libraries/LibGUI/GApplication.cpp
@@ -48,7 +48,7 @@ GApplication::GApplication(int argc, char** argv)
     (void)argv;
     ASSERT(!s_the);
     s_the = this;
-    m_event_loop = make<CEventLoop>();
+    m_event_loop = make<Core::EventLoop>();
     GWindowServerConnection::the();
     if (argc > 0)
         m_invoked_as = argv[0];
diff --git a/Libraries/LibGUI/GApplication.h b/Libraries/LibGUI/GApplication.h
index a1b783f325..0067d8da88 100644
--- a/Libraries/LibGUI/GApplication.h
+++ b/Libraries/LibGUI/GApplication.h
@@ -35,8 +35,10 @@
 namespace AK {
 class SharedBuffer;
 }
+namespace Core {
+class EventLoop;
+}
 
-class CEventLoop;
 class GAction;
 class GKeyEvent;
 class GMenuBar;
@@ -78,7 +80,7 @@ public:
     void set_system_palette(SharedBuffer&);
 
 private:
-    OwnPtr<CEventLoop> m_event_loop;
+    OwnPtr<Core::EventLoop> m_event_loop;
     OwnPtr<GMenuBar> m_menubar;
     RefPtr<PaletteImpl> m_palette;
     RefPtr<PaletteImpl> m_system_palette;
diff --git a/Libraries/LibGUI/GColorPicker.cpp b/Libraries/LibGUI/GColorPicker.cpp
index 50318b97be..8ff9f5ce45 100644
--- a/Libraries/LibGUI/GColorPicker.cpp
+++ b/Libraries/LibGUI/GColorPicker.cpp
@@ -31,7 +31,7 @@
 #include <LibGUI/GSpinBox.h>
 #include <LibGUI/GWidget.h>
 
-GColorPicker::GColorPicker(Color color, CObject* parent)
+GColorPicker::GColorPicker(Color color, Core::Object* parent)
     : GDialog(parent)
     , m_color(color)
 {
diff --git a/Libraries/LibGUI/GColorPicker.h b/Libraries/LibGUI/GColorPicker.h
index c9446753d0..4554270430 100644
--- a/Libraries/LibGUI/GColorPicker.h
+++ b/Libraries/LibGUI/GColorPicker.h
@@ -38,7 +38,7 @@ public:
     Color color() const { return m_color; }
 
 private:
-    explicit GColorPicker(Color, CObject* parent = nullptr);
+    explicit GColorPicker(Color, Core::Object* parent = nullptr);
 
     void build();
 
diff --git a/Libraries/LibGUI/GDialog.cpp b/Libraries/LibGUI/GDialog.cpp
index 0ff2200dda..22069c434a 100644
--- a/Libraries/LibGUI/GDialog.cpp
+++ b/Libraries/LibGUI/GDialog.cpp
@@ -28,7 +28,7 @@
 #include <LibGUI/GDialog.h>
 #include <LibGUI/GEvent.h>
 
-GDialog::GDialog(CObject* parent)
+GDialog::GDialog(Core::Object* parent)
     : GWindow(parent)
 {
     set_modal(true);
@@ -41,7 +41,7 @@ GDialog::~GDialog()
 int GDialog::exec()
 {
     ASSERT(!m_event_loop);
-    m_event_loop = make<CEventLoop>();
+    m_event_loop = make<Core::EventLoop>();
     auto new_rect = rect();
     if (parent() && parent()->is_window()) {
         auto& parent_window = *static_cast<GWindow*>(parent());
@@ -67,7 +67,7 @@ void GDialog::done(int result)
     m_event_loop->quit(result);
 }
 
-void GDialog::event(CEvent& event)
+void GDialog::event(Core::Event& event)
 {
     if (event.type() == GEvent::KeyUp) {
         auto& key_event = static_cast<GKeyEvent&>(event);
diff --git a/Libraries/LibGUI/GDialog.h b/Libraries/LibGUI/GDialog.h
index 788b85d645..4b5f8fd7b7 100644
--- a/Libraries/LibGUI/GDialog.h
+++ b/Libraries/LibGUI/GDialog.h
@@ -45,14 +45,14 @@ public:
     int result() const { return m_result; }
     void done(int result);
 
-    virtual void event(CEvent&) override;
+    virtual void event(Core::Event&) override;
 
     virtual void close() override;
 
 protected:
-    explicit GDialog(CObject* parent);
+    explicit GDialog(Core::Object* parent);
 
 private:
-    OwnPtr<CEventLoop> m_event_loop;
+    OwnPtr<Core::EventLoop> m_event_loop;
     int m_result { ExecAborted };
 };
diff --git a/Libraries/LibGUI/GDragOperation.cpp b/Libraries/LibGUI/GDragOperation.cpp
index ca09d2d624..04424b9494 100644
--- a/Libraries/LibGUI/GDragOperation.cpp
+++ b/Libraries/LibGUI/GDragOperation.cpp
@@ -30,8 +30,8 @@
 
 static GDragOperation* s_current_drag_operation;
 
-GDragOperation::GDragOperation(CObject* parent)
-    : CObject(parent)
+GDragOperation::GDragOperation(Core::Object* parent)
+    : Core::Object(parent)
 {
 }
 
@@ -61,7 +61,7 @@ GDragOperation::Outcome GDragOperation::exec()
     }
 
     s_current_drag_operation = this;
-    m_event_loop = make<CEventLoop>();
+    m_event_loop = make<Core::EventLoop>();
     auto result = m_event_loop->exec();
     m_event_loop = nullptr;
     dbgprintf("%s: event loop returned with result %d\n", class_name(), result);
diff --git a/Libraries/LibGUI/GDragOperation.h b/Libraries/LibGUI/GDragOperation.h
index 0a02ab403b..8713e4c34f 100644
--- a/Libraries/LibGUI/GDragOperation.h
+++ b/Libraries/LibGUI/GDragOperation.h
@@ -32,7 +32,7 @@
 class GraphicsBitmap;
 class GWindowServerConnection;
 
-class GDragOperation : public CObject {
+class GDragOperation : public Core::Object {
     C_OBJECT(GDragOperation)
 public:
     enum class Outcome {
@@ -58,12 +58,12 @@ public:
     static void notify_cancelled(Badge<GWindowServerConnection>);
 
 protected:
-    explicit GDragOperation(CObject* parent = nullptr);
+    explicit GDragOperation(Core::Object* parent = nullptr);
 
 private:
     void done(Outcome);
 
-    OwnPtr<CEventLoop> m_event_loop;
+    OwnPtr<Core::EventLoop> m_event_loop;
     Outcome m_outcome { Outcome::None };
     String m_text;
     String m_data_type;
diff --git a/Libraries/LibGUI/GEvent.h b/Libraries/LibGUI/GEvent.h
index 5a1457de81..59d65fabc5 100644
--- a/Libraries/LibGUI/GEvent.h
+++ b/Libraries/LibGUI/GEvent.h
@@ -32,9 +32,7 @@
 #include <LibDraw/Rect.h>
 #include <LibGUI/GWindowType.h>
 
-class CObject;
-
-class GEvent : public CEvent {
+class GEvent : public Core::Event {
 public:
     enum Type {
         Show = 1000,
@@ -72,7 +70,7 @@ public:
 
     GEvent() {}
     explicit GEvent(Type type)
-        : CEvent(type)
+        : Core::Event(type)
     {
     }
     virtual ~GEvent() {}
diff --git a/Libraries/LibGUI/GFilePicker.cpp b/Libraries/LibGUI/GFilePicker.cpp
index ab4a538da0..d510fc456f 100644
--- a/Libraries/LibGUI/GFilePicker.cpp
+++ b/Libraries/LibGUI/GFilePicker.cpp
@@ -72,7 +72,7 @@ Optional<String> GFilePicker::get_save_filepath(const String& title, const Strin
     return {};
 }
 
-GFilePicker::GFilePicker(Mode mode, const StringView& file_name, const StringView& path, CObject* parent)
+GFilePicker::GFilePicker(Mode mode, const StringView& file_name, const StringView& path, Core::Object* parent)
     : GDialog(parent)
     , m_model(GFileSystemModel::create())
     , m_mode(mode)
diff --git a/Libraries/LibGUI/GFilePicker.h b/Libraries/LibGUI/GFilePicker.h
index 04ce58a35f..21beee489b 100644
--- a/Libraries/LibGUI/GFilePicker.h
+++ b/Libraries/LibGUI/GFilePicker.h
@@ -55,7 +55,7 @@ private:
     void clear_preview();
     void on_file_return();
 
-    GFilePicker(Mode type = Mode::Open, const StringView& file_name = "Untitled", const StringView& path = String(get_current_user_home_path()), CObject* parent = nullptr);
+    GFilePicker(Mode type = Mode::Open, const StringView& file_name = "Untitled", const StringView& path = String(get_current_user_home_path()), Core::Object* parent = nullptr);
 
     static String ok_button_name(Mode mode)
     {
diff --git a/Libraries/LibGUI/GFileSystemModel.cpp b/Libraries/LibGUI/GFileSystemModel.cpp
index ed532d5500..4c8d28598b 100644
--- a/Libraries/LibGUI/GFileSystemModel.cpp
+++ b/Libraries/LibGUI/GFileSystemModel.cpp
@@ -91,7 +91,7 @@ void GFileSystemModel::Node::traverse_if_needed(const GFileSystemModel& model)
     total_size = 0;
 
     auto full_path = this->full_path(model);
-    CDirIterator di(full_path, CDirIterator::SkipDots);
+    Core::DirIterator di(full_path, Core::DirIterator::SkipDots);
     if (di.has_error()) {
         fprintf(stderr, "CDirIterator: %s\n", di.error_string());
         return;
@@ -122,7 +122,7 @@ void GFileSystemModel::Node::traverse_if_needed(const GFileSystemModel& model)
     }
     fcntl(m_watch_fd, F_SETFD, FD_CLOEXEC);
     dbg() << "Watching " << full_path << " for changes, m_watch_fd = " << m_watch_fd;
-    m_notifier = CNotifier::construct(m_watch_fd, CNotifier::Event::Read);
+    m_notifier = Core::Notifier::construct(m_watch_fd, Core::Notifier::Event::Read);
     m_notifier->on_ready_to_read = [this, &model] {
         char buffer[32];
         int rc = read(m_notifier->fd(), buffer, sizeof(buffer));
diff --git a/Libraries/LibGUI/GFileSystemModel.h b/Libraries/LibGUI/GFileSystemModel.h
index 276c99df50..971a1b0001 100644
--- a/Libraries/LibGUI/GFileSystemModel.h
+++ b/Libraries/LibGUI/GFileSystemModel.h
@@ -85,7 +85,7 @@ public:
         bool has_traversed { false };
 
         int m_watch_fd { -1 };
-        RefPtr<CNotifier> m_notifier;
+        RefPtr<Core::Notifier> m_notifier;
 
         GModelIndex index(const GFileSystemModel&, int column) const;
         void traverse_if_needed(const GFileSystemModel&);
diff --git a/Libraries/LibGUI/GFontDatabase.cpp b/Libraries/LibGUI/GFontDatabase.cpp
index d01a414b50..80883ac51b 100644
--- a/Libraries/LibGUI/GFontDatabase.cpp
+++ b/Libraries/LibGUI/GFontDatabase.cpp
@@ -43,7 +43,7 @@ GFontDatabase& GFontDatabase::the()
 
 GFontDatabase::GFontDatabase()
 {
-    CDirIterator di("/res/fonts", CDirIterator::SkipDots);
+    Core::DirIterator di("/res/fonts", Core::DirIterator::SkipDots);
     if (di.has_error()) {
         fprintf(stderr, "CDirIterator: %s\n", di.error_string());
         exit(1);
diff --git a/Libraries/LibGUI/GInputBox.cpp b/Libraries/LibGUI/GInputBox.cpp
index e43e4d0dac..709c3b0861 100644
--- a/Libraries/LibGUI/GInputBox.cpp
+++ b/Libraries/LibGUI/GInputBox.cpp
@@ -31,7 +31,7 @@
 #include <LibGUI/GTextEditor.h>
 #include <stdio.h>
 
-GInputBox::GInputBox(const StringView& prompt, const StringView& title, CObject* parent)
+GInputBox::GInputBox(const StringView& prompt, const StringView& title, Core::Object* parent)
     : GDialog(parent)
     , m_prompt(prompt)
 {
diff --git a/Libraries/LibGUI/GInputBox.h b/Libraries/LibGUI/GInputBox.h
index beb5a54c8a..a957ccdba1 100644
--- a/Libraries/LibGUI/GInputBox.h
+++ b/Libraries/LibGUI/GInputBox.h
@@ -34,7 +34,7 @@ class GTextEditor;
 class GInputBox : public GDialog {
     C_OBJECT(GInputBox)
 public:
-    explicit GInputBox(const StringView& prompt, const StringView& title, CObject* parent = nullptr);
+    explicit GInputBox(const StringView& prompt, const StringView& title, Core::Object* parent = nullptr);
     virtual ~GInputBox() override;
 
     String text_value() const { return m_text_value; }
diff --git a/Libraries/LibGUI/GJsonArrayModel.cpp b/Libraries/LibGUI/GJsonArrayModel.cpp
index 7f9d988a19..f706a08ab0 100644
--- a/Libraries/LibGUI/GJsonArrayModel.cpp
+++ b/Libraries/LibGUI/GJsonArrayModel.cpp
@@ -30,8 +30,8 @@
 
 void GJsonArrayModel::update()
 {
-    auto file = CFile::construct(m_json_path);
-    if (!file->open(CIODevice::ReadOnly)) {
+    auto file = Core::File::construct(m_json_path);
+    if (!file->open(Core::IODevice::ReadOnly)) {
         dbg() << "Unable to open " << file->filename();
         m_array.clear();
         did_update();
diff --git a/Libraries/LibGUI/GMenu.h b/Libraries/LibGUI/GMenu.h
index 885f7315cd..0c4820d294 100644
--- a/Libraries/LibGUI/GMenu.h
+++ b/Libraries/LibGUI/GMenu.h
@@ -35,7 +35,7 @@
 class GAction;
 class Point;
 
-class GMenu final : public CObject {
+class GMenu final : public Core::Object {
     C_OBJECT(GMenu)
 public:
     explicit GMenu(const StringView& name = "");
diff --git a/Libraries/LibGUI/GMessageBox.cpp b/Libraries/LibGUI/GMessageBox.cpp
index 9a38040fa7..ab7b0769d0 100644
--- a/Libraries/LibGUI/GMessageBox.cpp
+++ b/Libraries/LibGUI/GMessageBox.cpp
@@ -30,13 +30,13 @@
 #include <LibGUI/GMessageBox.h>
 #include <stdio.h>
 
-int GMessageBox::show(const StringView& text, const StringView& title, Type type, InputType input_type, CObject* parent)
+int GMessageBox::show(const StringView& text, const StringView& title, Type type, InputType input_type, Core::Object* parent)
 {
     auto box = GMessageBox::construct(text, title, type, input_type, parent);
     return box->exec();
 }
 
-GMessageBox::GMessageBox(const StringView& text, const StringView& title, Type type, InputType input_type, CObject* parent)
+GMessageBox::GMessageBox(const StringView& text, const StringView& title, Type type, InputType input_type, Core::Object* parent)
     : GDialog(parent)
     , m_text(text)
     , m_type(type)
diff --git a/Libraries/LibGUI/GMessageBox.h b/Libraries/LibGUI/GMessageBox.h
index 2b7c62d448..f0df664d71 100644
--- a/Libraries/LibGUI/GMessageBox.h
+++ b/Libraries/LibGUI/GMessageBox.h
@@ -45,10 +45,10 @@ public:
 
     virtual ~GMessageBox() override;
 
-    static int show(const StringView& text, const StringView& title, Type type = Type::None, InputType = InputType::OK, CObject* parent = nullptr);
+    static int show(const StringView& text, const StringView& title, Type type = Type::None, InputType = InputType::OK, Core::Object* parent = nullptr);
 
 private:
-    explicit GMessageBox(const StringView& text, const StringView& title, Type type = Type::None, InputType = InputType::OK, CObject* parent = nullptr);
+    explicit GMessageBox(const StringView& text, const StringView& title, Type type = Type::None, InputType = InputType::OK, Core::Object* parent = nullptr);
 
     bool should_include_ok_button() const;
     bool should_include_cancel_button() const;
diff --git a/Libraries/LibGUI/GRadioButton.h b/Libraries/LibGUI/GRadioButton.h
index be2217039f..4c905ca893 100644
--- a/Libraries/LibGUI/GRadioButton.h
+++ b/Libraries/LibGUI/GRadioButton.h
@@ -53,7 +53,7 @@ private:
 };
 
 template<>
-inline bool is<GRadioButton>(const CObject& object)
+inline bool Core::is<GRadioButton>(const Core::Object& object)
 {
     if (!is<GWidget>(object))
         return false;
diff --git a/Libraries/LibGUI/GResizeCorner.cpp b/Libraries/LibGUI/GResizeCorner.cpp
index 49a5b88daf..ce84aa2bef 100644
--- a/Libraries/LibGUI/GResizeCorner.cpp
+++ b/Libraries/LibGUI/GResizeCorner.cpp
@@ -60,13 +60,13 @@ void GResizeCorner::mousedown_event(GMouseEvent& event)
     GWidget::mousedown_event(event);
 }
 
-void GResizeCorner::enter_event(CEvent& event)
+void GResizeCorner::enter_event(Core::Event& event)
 {
     window()->set_override_cursor(GStandardCursor::ResizeDiagonalTLBR);
     GWidget::enter_event(event);
 }
 
-void GResizeCorner::leave_event(CEvent& event)
+void GResizeCorner::leave_event(Core::Event& event)
 {
     window()->set_override_cursor(GStandardCursor::None);
     GWidget::leave_event(event);
diff --git a/Libraries/LibGUI/GResizeCorner.h b/Libraries/LibGUI/GResizeCorner.h
index 682afc7652..7f27928d93 100644
--- a/Libraries/LibGUI/GResizeCorner.h
+++ b/Libraries/LibGUI/GResizeCorner.h
@@ -36,8 +36,8 @@ protected:
 
     virtual void paint_event(GPaintEvent&) override;
     virtual void mousedown_event(GMouseEvent&) override;
-    virtual void enter_event(CEvent&) override;
-    virtual void leave_event(CEvent&) override;
+    virtual void enter_event(Core::Event&) override;
+    virtual void leave_event(Core::Event&) override;
 
 private:
     RefPtr<GraphicsBitmap> m_bitmap;
diff --git a/Libraries/LibGUI/GScrollBar.cpp b/Libraries/LibGUI/GScrollBar.cpp
index b278b8331e..5b70bb9bc7 100644
--- a/Libraries/LibGUI/GScrollBar.cpp
+++ b/Libraries/LibGUI/GScrollBar.cpp
@@ -93,7 +93,7 @@ GScrollBar::GScrollBar(Orientation orientation, GWidget* parent)
     : GWidget(parent)
     , m_orientation(orientation)
 {
-    m_automatic_scrolling_timer = CTimer::construct(this);
+    m_automatic_scrolling_timer = Core::Timer::construct(this);
     if (!s_up_arrow_bitmap)
         s_up_arrow_bitmap = &CharacterBitmap::create_from_ascii(s_up_arrow_bitmap_data, 9, 9).leak_ref();
     if (!s_down_arrow_bitmap)
@@ -355,7 +355,7 @@ void GScrollBar::mousemove_event(GMouseEvent& event)
     set_value(new_value);
 }
 
-void GScrollBar::leave_event(CEvent&)
+void GScrollBar::leave_event(Core::Event&)
 {
     if (m_hovered_component != Component::Invalid) {
         m_hovered_component = Component::Invalid;
diff --git a/Libraries/LibGUI/GScrollBar.h b/Libraries/LibGUI/GScrollBar.h
index bb4abd940d..dcb5dc84ae 100644
--- a/Libraries/LibGUI/GScrollBar.h
+++ b/Libraries/LibGUI/GScrollBar.h
@@ -72,7 +72,7 @@ private:
     virtual void mouseup_event(GMouseEvent&) override;
     virtual void mousemove_event(GMouseEvent&) override;
     virtual void mousewheel_event(GMouseEvent&) override;
-    virtual void leave_event(CEvent&) override;
+    virtual void leave_event(Core::Event&) override;
     virtual void change_event(GEvent&) override;
 
     int default_button_size() const { return 16; }
@@ -110,5 +110,5 @@ private:
     };
 
     AutomaticScrollingDirection m_automatic_scrolling_direction { AutomaticScrollingDirection::None };
-    RefPtr<CTimer> m_automatic_scrolling_timer;
+    RefPtr<Core::Timer> m_automatic_scrolling_timer;
 };
diff --git a/Libraries/LibGUI/GSlider.cpp b/Libraries/LibGUI/GSlider.cpp
index 8f07095dfb..610cb151a4 100644
--- a/Libraries/LibGUI/GSlider.cpp
+++ b/Libraries/LibGUI/GSlider.cpp
@@ -162,7 +162,7 @@ void GSlider::mouseup_event(GMouseEvent& event)
     return GWidget::mouseup_event(event);
 }
 
-void GSlider::leave_event(CEvent& event)
+void GSlider::leave_event(Core::Event& event)
 {
     if (!is_enabled())
         return;
diff --git a/Libraries/LibGUI/GSlider.h b/Libraries/LibGUI/GSlider.h
index 1dc1eb2ddb..1ad1034c5a 100644
--- a/Libraries/LibGUI/GSlider.h
+++ b/Libraries/LibGUI/GSlider.h
@@ -77,7 +77,7 @@ protected:
     virtual void mousedown_event(GMouseEvent&) override;
     virtual void mousemove_event(GMouseEvent&) override;
     virtual void mouseup_event(GMouseEvent&) override;
-    virtual void leave_event(CEvent&) override;
+    virtual void leave_event(Core::Event&) override;
     virtual void change_event(GEvent&) override;
 
 private:
diff --git a/Libraries/LibGUI/GSplitter.cpp b/Libraries/LibGUI/GSplitter.cpp
index e1e689ed07..431bf8db3c 100644
--- a/Libraries/LibGUI/GSplitter.cpp
+++ b/Libraries/LibGUI/GSplitter.cpp
@@ -43,14 +43,14 @@ GSplitter::~GSplitter()
 {
 }
 
-void GSplitter::enter_event(CEvent&)
+void GSplitter::enter_event(Core::Event&)
 {
     set_background_role(ColorRole::HoverHighlight);
     window()->set_override_cursor(m_orientation == Orientation::Horizontal ? GStandardCursor::ResizeHorizontal : GStandardCursor::ResizeVertical);
     update();
 }
 
-void GSplitter::leave_event(CEvent&)
+void GSplitter::leave_event(Core::Event&)
 {
     set_background_role(ColorRole::Button);
     if (!m_resizing)
diff --git a/Libraries/LibGUI/GSplitter.h b/Libraries/LibGUI/GSplitter.h
index ff45769ed3..e061f7887f 100644
--- a/Libraries/LibGUI/GSplitter.h
+++ b/Libraries/LibGUI/GSplitter.h
@@ -39,8 +39,8 @@ protected:
     virtual void mousedown_event(GMouseEvent&) override;
     virtual void mousemove_event(GMouseEvent&) override;
     virtual void mouseup_event(GMouseEvent&) override;
-    virtual void enter_event(CEvent&) override;
-    virtual void leave_event(CEvent&) override;
+    virtual void enter_event(Core::Event&) override;
+    virtual void leave_event(Core::Event&) override;
 
 private:
     Orientation m_orientation;
diff --git a/Libraries/LibGUI/GStackWidget.cpp b/Libraries/LibGUI/GStackWidget.cpp
index 548f38890f..6895948c99 100644
--- a/Libraries/LibGUI/GStackWidget.cpp
+++ b/Libraries/LibGUI/GStackWidget.cpp
@@ -59,11 +59,11 @@ void GStackWidget::resize_event(GResizeEvent& event)
     m_active_widget->set_relative_rect({ {}, event.size() });
 }
 
-void GStackWidget::child_event(CChildEvent& event)
+void GStackWidget::child_event(Core::ChildEvent& event)
 {
-    if (!event.child() || !is<GWidget>(*event.child()))
+    if (!event.child() || !Core::is<GWidget>(*event.child()))
         return GWidget::child_event(event);
-    auto& child = to<GWidget>(*event.child());
+    auto& child = Core::to<GWidget>(*event.child());
     if (event.type() == GEvent::ChildAdded) {
         if (!m_active_widget)
             set_active_widget(&child);
diff --git a/Libraries/LibGUI/GStackWidget.h b/Libraries/LibGUI/GStackWidget.h
index 0bb240c137..2cd071576e 100644
--- a/Libraries/LibGUI/GStackWidget.h
+++ b/Libraries/LibGUI/GStackWidget.h
@@ -41,7 +41,7 @@ public:
 
 protected:
     explicit GStackWidget(GWidget* parent);
-    virtual void child_event(CChildEvent&) override;
+    virtual void child_event(Core::ChildEvent&) override;
     virtual void resize_event(GResizeEvent&) override;
 
 private:
diff --git a/Libraries/LibGUI/GTabWidget.cpp b/Libraries/LibGUI/GTabWidget.cpp
index 10d2d41dc3..c9a45d2936 100644
--- a/Libraries/LibGUI/GTabWidget.cpp
+++ b/Libraries/LibGUI/GTabWidget.cpp
@@ -84,11 +84,11 @@ Rect GTabWidget::child_rect_for_size(const Size& size) const
     return rect;
 }
 
-void GTabWidget::child_event(CChildEvent& event)
+void GTabWidget::child_event(Core::ChildEvent& event)
 {
-    if (!event.child() || !is<GWidget>(*event.child()))
+    if (!event.child() || !Core::is<GWidget>(*event.child()))
         return GWidget::child_event(event);
-    auto& child = to<GWidget>(*event.child());
+    auto& child = Core::to<GWidget>(*event.child());
     if (event.type() == GEvent::ChildAdded) {
         if (!m_active_widget)
             set_active_widget(&child);
@@ -214,7 +214,7 @@ void GTabWidget::mousemove_event(GMouseEvent& event)
     update_bar();
 }
 
-void GTabWidget::leave_event(CEvent&)
+void GTabWidget::leave_event(Core::Event&)
 {
     if (m_hovered_tab_index != -1) {
         m_hovered_tab_index = -1;
diff --git a/Libraries/LibGUI/GTabWidget.h b/Libraries/LibGUI/GTabWidget.h
index 15a428acdf..72514b2505 100644
--- a/Libraries/LibGUI/GTabWidget.h
+++ b/Libraries/LibGUI/GTabWidget.h
@@ -55,11 +55,11 @@ public:
 
 protected:
     virtual void paint_event(GPaintEvent&) override;
-    virtual void child_event(CChildEvent&) override;
+    virtual void child_event(Core::ChildEvent&) override;
     virtual void resize_event(GResizeEvent&) override;
     virtual void mousedown_event(GMouseEvent&) override;
     virtual void mousemove_event(GMouseEvent&) override;
-    virtual void leave_event(CEvent&) override;
+    virtual void leave_event(Core::Event&) override;
 
 private:
     Rect child_rect_for_size(const Size&) const;
diff --git a/Libraries/LibGUI/GTextDocument.cpp b/Libraries/LibGUI/GTextDocument.cpp
index e751ca533e..c6389cb0a8 100644
--- a/Libraries/LibGUI/GTextDocument.cpp
+++ b/Libraries/LibGUI/GTextDocument.cpp
@@ -37,7 +37,7 @@ GTextDocument::GTextDocument(Client* client)
     append_line(make<GTextDocumentLine>(*this));
 
     // TODO: Instead of a repating timer, this we should call a delayed 2 sec timer when the user types.
-    m_undo_timer = CTimer::construct(
+    m_undo_timer = Core::Timer::construct(
         2000, [this] {
             update_undo_timer();
         });
diff --git a/Libraries/LibGUI/GTextDocument.h b/Libraries/LibGUI/GTextDocument.h
index fb974c3221..7e12e14b80 100644
--- a/Libraries/LibGUI/GTextDocument.h
+++ b/Libraries/LibGUI/GTextDocument.h
@@ -146,7 +146,7 @@ private:
     bool m_client_notifications_enabled { true };
 
     GUndoStack m_undo_stack;
-    RefPtr<CTimer> m_undo_timer;
+    RefPtr<Core::Timer> m_undo_timer;
 };
 
 class GTextDocumentLine {
diff --git a/Libraries/LibGUI/GTextEditor.cpp b/Libraries/LibGUI/GTextEditor.cpp
index baccab38c7..50f162322f 100644
--- a/Libraries/LibGUI/GTextEditor.cpp
+++ b/Libraries/LibGUI/GTextEditor.cpp
@@ -235,7 +235,7 @@ void GTextEditor::mousedown_event(GMouseEvent& event)
     }
 
     if (m_triple_click_timer.is_valid() && m_triple_click_timer.elapsed() < 250) {
-        m_triple_click_timer = CElapsedTimer();
+        m_triple_click_timer = Core::ElapsedTimer();
 
         GTextPosition start;
         GTextPosition end;
@@ -1030,18 +1030,18 @@ void GTextEditor::set_cursor(const GTextPosition& a_position)
         on_cursor_change();
 }
 
-void GTextEditor::focusin_event(CEvent&)
+void GTextEditor::focusin_event(Core::Event&)
 {
     update_cursor();
     start_timer(500);
 }
 
-void GTextEditor::focusout_event(CEvent&)
+void GTextEditor::focusout_event(Core::Event&)
 {
     stop_timer();
 }
 
-void GTextEditor::timer_event(CTimerEvent&)
+void GTextEditor::timer_event(Core::TimerEvent&)
 {
     m_cursor_state = !m_cursor_state;
     if (is_focused())
@@ -1171,13 +1171,13 @@ void GTextEditor::paste()
     insert_at_cursor_or_replace_selection(paste_text);
 }
 
-void GTextEditor::enter_event(CEvent&)
+void GTextEditor::enter_event(Core::Event&)
 {
     ASSERT(window());
     window()->set_override_cursor(GStandardCursor::IBeam);
 }
 
-void GTextEditor::leave_event(CEvent&)
+void GTextEditor::leave_event(Core::Event&)
 {
     ASSERT(window());
     window()->set_override_cursor(GStandardCursor::None);
diff --git a/Libraries/LibGUI/GTextEditor.h b/Libraries/LibGUI/GTextEditor.h
index b278a49a61..8c67fce7b5 100644
--- a/Libraries/LibGUI/GTextEditor.h
+++ b/Libraries/LibGUI/GTextEditor.h
@@ -142,12 +142,12 @@ protected:
     virtual void mousemove_event(GMouseEvent&) override;
     virtual void doubleclick_event(GMouseEvent&) override;
     virtual void keydown_event(GKeyEvent&) override;
-    virtual void focusin_event(CEvent&) override;
-    virtual void focusout_event(CEvent&) override;
-    virtual void timer_event(CTimerEvent&) override;
+    virtual void focusin_event(Core::Event&) override;
+    virtual void focusout_event(Core::Event&) override;
+    virtual void timer_event(Core::TimerEvent&) override;
     virtual bool accepts_focus() const override { return true; }
-    virtual void enter_event(CEvent&) override;
-    virtual void leave_event(CEvent&) override;
+    virtual void enter_event(Core::Event&) override;
+    virtual void leave_event(Core::Event&) override;
     virtual void context_menu_event(GContextMenuEvent&) override;
     virtual void resize_event(GResizeEvent&) override;
     virtual void cursor_did_change() {}
@@ -232,7 +232,7 @@ private:
     RefPtr<GAction> m_paste_action;
     RefPtr<GAction> m_delete_action;
     RefPtr<GAction> m_go_to_line_action;
-    CElapsedTimer m_triple_click_timer;
+    Core::ElapsedTimer m_triple_click_timer;
     NonnullRefPtrVector<GAction> m_custom_context_menu_actions;
 
     RefPtr<GTextDocument> m_document;
diff --git a/Libraries/LibGUI/GWidget.cpp b/Libraries/LibGUI/GWidget.cpp
index 0ee5a83356..f4c76f1e1e 100644
--- a/Libraries/LibGUI/GWidget.cpp
+++ b/Libraries/LibGUI/GWidget.cpp
@@ -91,7 +91,7 @@ const GWidgetClassRegistration* GWidgetClassRegistration::find(const String& cla
 }
 
 GWidget::GWidget(GWidget* parent)
-    : CObject(parent, true)
+    : Core::Object(parent, true)
     , m_font(Font::default_font())
     , m_palette(GApplication::the().palette().impl())
 {
@@ -101,26 +101,26 @@ GWidget::~GWidget()
 {
 }
 
-void GWidget::child_event(CChildEvent& event)
+void GWidget::child_event(Core::ChildEvent& event)
 {
     if (event.type() == GEvent::ChildAdded) {
-        if (event.child() && is<GWidget>(*event.child()) && layout()) {
+        if (event.child() && Core::is<GWidget>(*event.child()) && layout()) {
             if (event.insertion_before_child() && event.insertion_before_child()->is_widget())
-                layout()->insert_widget_before(to<GWidget>(*event.child()), to<GWidget>(*event.insertion_before_child()));
+                layout()->insert_widget_before(Core::to<GWidget>(*event.child()), Core::to<GWidget>(*event.insertion_before_child()));
             else
-                layout()->add_widget(to<GWidget>(*event.child()));
+                layout()->add_widget(Core::to<GWidget>(*event.child()));
         }
     }
     if (event.type() == GEvent::ChildRemoved) {
         if (layout()) {
-            if (event.child() && is<GWidget>(*event.child()))
-                layout()->remove_widget(to<GWidget>(*event.child()));
+            if (event.child() && Core::is<GWidget>(*event.child()))
+                layout()->remove_widget(Core::to<GWidget>(*event.child()));
             else
                 invalidate_layout();
         }
         update();
     }
-    return CObject::child_event(event);
+    return Core::Object::child_event(event);
 }
 
 void GWidget::set_relative_rect(const Rect& a_rect)
@@ -151,7 +151,7 @@ void GWidget::set_relative_rect(const Rect& a_rect)
     update();
 }
 
-void GWidget::event(CEvent& event)
+void GWidget::event(Core::Event& event)
 {
     switch (event.type()) {
     case GEvent::Paint:
@@ -189,7 +189,7 @@ void GWidget::event(CEvent& event)
     case GEvent::EnabledChange:
         return change_event(static_cast<GEvent&>(event));
     default:
-        return CObject::event(event);
+        return Core::Object::event(event);
     }
 }
 
@@ -278,14 +278,14 @@ void GWidget::handle_mousedoubleclick_event(GMouseEvent& event)
     doubleclick_event(event);
 }
 
-void GWidget::handle_enter_event(CEvent& event)
+void GWidget::handle_enter_event(Core::Event& event)
 {
     if (has_tooltip())
         GApplication::the().show_tooltip(m_tooltip, screen_relative_rect().center().translated(0, height() / 2));
     enter_event(event);
 }
 
-void GWidget::handle_leave_event(CEvent& event)
+void GWidget::handle_leave_event(Core::Event& event)
 {
     GApplication::the().hide_tooltip();
     leave_event(event);
@@ -356,19 +356,19 @@ void GWidget::context_menu_event(GContextMenuEvent&)
 {
 }
 
-void GWidget::focusin_event(CEvent&)
+void GWidget::focusin_event(Core::Event&)
 {
 }
 
-void GWidget::focusout_event(CEvent&)
+void GWidget::focusout_event(Core::Event&)
 {
 }
 
-void GWidget::enter_event(CEvent&)
+void GWidget::enter_event(Core::Event&)
 {
 }
 
-void GWidget::leave_event(CEvent&)
+void GWidget::leave_event(Core::Event&)
 {
 }
 
@@ -426,9 +426,9 @@ Rect GWidget::screen_relative_rect() const
 GWidget* GWidget::child_at(const Point& point) const
 {
     for (int i = children().size() - 1; i >= 0; --i) {
-        if (!is<GWidget>(children()[i]))
+        if (!Core::is<GWidget>(children()[i]))
             continue;
-        auto& child = to<GWidget>(children()[i]);
+        auto& child = Core::to<GWidget>(children()[i]);
         if (!child.is_visible())
             continue;
         if (child.relative_rect().contains(point))
@@ -701,7 +701,7 @@ void GWidget::save_to(AK::JsonObject& json)
     json.set("foreground_color", foreground_color().to_string());
     json.set("preferred_size", preferred_size().to_string());
     json.set("size_policy", String::format("[%s,%s]", to_string(horizontal_size_policy()), to_string(vertical_size_policy())));
-    CObject::save_to(json);
+    Core::Object::save_to(json);
 }
 
 Vector<GWidget*> GWidget::child_widgets() const
diff --git a/Libraries/LibGUI/GWidget.h b/Libraries/LibGUI/GWidget.h
index f9a3921564..9efeac0780 100644
--- a/Libraries/LibGUI/GWidget.h
+++ b/Libraries/LibGUI/GWidget.h
@@ -94,7 +94,7 @@ private:
     Function<NonnullRefPtr<GWidget>(GWidget*)> m_factory;
 };
 
-class GWidget : public CObject {
+class GWidget : public Core::Object {
     C_OBJECT(GWidget)
 public:
     virtual ~GWidget() override;
@@ -123,7 +123,7 @@ public:
     bool updates_enabled() const { return m_updates_enabled; }
     void set_updates_enabled(bool);
 
-    virtual void event(CEvent&) override;
+    virtual void event(Core::Event&) override;
 
     // This is called after children have been painted.
     virtual void second_paint_event(GPaintEvent&);
@@ -245,8 +245,8 @@ public:
     void for_each_child_widget(Callback callback)
     {
         for_each_child([&](auto& child) {
-            if (is<GWidget>(child))
-                return callback(to<GWidget>(child));
+            if (Core::is<GWidget>(child))
+                return callback(Core::to<GWidget>(child));
             return IterationDecision::Continue;
         });
     }
@@ -281,11 +281,11 @@ protected:
     virtual void click_event(GMouseEvent&);
     virtual void doubleclick_event(GMouseEvent&);
     virtual void context_menu_event(GContextMenuEvent&);
-    virtual void focusin_event(CEvent&);
-    virtual void focusout_event(CEvent&);
-    virtual void enter_event(CEvent&);
-    virtual void leave_event(CEvent&);
-    virtual void child_event(CChildEvent&) override;
+    virtual void focusin_event(Core::Event&);
+    virtual void focusout_event(Core::Event&);
+    virtual void enter_event(Core::Event&);
+    virtual void leave_event(Core::Event&);
+    virtual void child_event(Core::ChildEvent&) override;
     virtual void change_event(GEvent&);
     virtual void drop_event(GDropEvent&);
 
@@ -295,8 +295,8 @@ private:
     void handle_mousedown_event(GMouseEvent&);
     void handle_mousedoubleclick_event(GMouseEvent&);
     void handle_mouseup_event(GMouseEvent&);
-    void handle_enter_event(CEvent&);
-    void handle_leave_event(CEvent&);
+    void handle_enter_event(Core::Event&);
+    void handle_leave_event(Core::Event&);
     void focus_previous_widget();
     void focus_next_widget();
 
@@ -326,20 +326,20 @@ private:
 };
 
 template<>
-inline bool is<GWidget>(const CObject& object)
+inline bool Core::is<GWidget>(const Core::Object& object)
 {
     return object.is_widget();
 }
 
 inline GWidget* GWidget::parent_widget()
 {
-    if (parent() && is<GWidget>(*parent()))
-        return &to<GWidget>(*parent());
+    if (parent() && Core::is<GWidget>(*parent()))
+        return &Core::to<GWidget>(*parent());
     return nullptr;
 }
 inline const GWidget* GWidget::parent_widget() const
 {
-    if (parent() && is<GWidget>(*parent()))
-        return &to<const GWidget>(*parent());
+    if (parent() && Core::is<GWidget>(*parent()))
+        return &Core::to<const GWidget>(*parent());
     return nullptr;
 }
diff --git a/Libraries/LibGUI/GWindow.cpp b/Libraries/LibGUI/GWindow.cpp
index 4bab839163..d60c49a3ca 100644
--- a/Libraries/LibGUI/GWindow.cpp
+++ b/Libraries/LibGUI/GWindow.cpp
@@ -53,8 +53,8 @@ GWindow* GWindow::from_window_id(int window_id)
     return nullptr;
 }
 
-GWindow::GWindow(CObject* parent)
-    : CObject(parent)
+GWindow::GWindow(Core::Object* parent)
+    : Core::Object(parent)
 {
     all_windows->set(this);
     m_rect_when_windowless = { 100, 400, 140, 140 };
@@ -179,7 +179,7 @@ void GWindow::set_override_cursor(GStandardCursor cursor)
     GWindowServerConnection::the().send_sync<WindowServer::SetWindowOverrideCursor>(m_window_id, (u32)cursor);
 }
 
-void GWindow::event(CEvent& event)
+void GWindow::event(Core::Event& event)
 {
     if (event.type() == GEvent::Drop) {
         auto& drop_event = static_cast<GDropEvent&>(event);
@@ -317,7 +317,7 @@ void GWindow::event(CEvent& event)
     if (event.type() > GEvent::__Begin_WM_Events && event.type() < GEvent::__End_WM_Events)
         return wm_event(static_cast<GWMEvent&>(event));
 
-    CObject::event(event);
+    Core::Object::event(event);
 }
 
 bool GWindow::is_visible() const
@@ -386,12 +386,12 @@ void GWindow::set_focused_widget(GWidget* widget)
     if (m_focused_widget == widget)
         return;
     if (m_focused_widget) {
-        CEventLoop::current().post_event(*m_focused_widget, make<GEvent>(GEvent::FocusOut));
+        Core::EventLoop::current().post_event(*m_focused_widget, make<GEvent>(GEvent::FocusOut));
         m_focused_widget->update();
     }
     m_focused_widget = widget ? widget->make_weak_ptr() : nullptr;
     if (m_focused_widget) {
-        CEventLoop::current().post_event(*m_focused_widget, make<GEvent>(GEvent::FocusIn));
+        Core::EventLoop::current().post_event(*m_focused_widget, make<GEvent>(GEvent::FocusIn));
         m_focused_widget->update();
     }
 }
@@ -446,12 +446,12 @@ void GWindow::set_hovered_widget(GWidget* widget)
         return;
 
     if (m_hovered_widget)
-        CEventLoop::current().post_event(*m_hovered_widget, make<GEvent>(GEvent::Leave));
+        Core::EventLoop::current().post_event(*m_hovered_widget, make<GEvent>(GEvent::Leave));
 
     m_hovered_widget = widget ? widget->make_weak_ptr() : nullptr;
 
     if (m_hovered_widget)
-        CEventLoop::current().post_event(*m_hovered_widget, make<GEvent>(GEvent::Enter));
+        Core::EventLoop::current().post_event(*m_hovered_widget, make<GEvent>(GEvent::Enter));
 }
 
 void GWindow::set_current_backing_bitmap(GraphicsBitmap& bitmap, bool flush_immediately)
@@ -583,7 +583,7 @@ void GWindow::save_to(AK::JsonObject& json)
     json.set("rect", rect().to_string());
     json.set("base_size", base_size().to_string());
     json.set("size_increment", size_increment().to_string());
-    CObject::save_to(json);
+    Core::Object::save_to(json);
 }
 
 void GWindow::set_fullscreen(bool fullscreen)
diff --git a/Libraries/LibGUI/GWindow.h b/Libraries/LibGUI/GWindow.h
index ae47f1efe8..708ebfe707 100644
--- a/Libraries/LibGUI/GWindow.h
+++ b/Libraries/LibGUI/GWindow.h
@@ -52,7 +52,7 @@ enum class GStandardCursor {
     Hand,
 };
 
-class GWindow : public CObject {
+class GWindow : public Core::Object {
     C_OBJECT(GWindow)
 public:
     virtual ~GWindow() override;
@@ -112,7 +112,7 @@ public:
     void resize(int width, int height) { resize({ width, height }); }
     void resize(const Size& size) { set_rect({ position(), size }); }
 
-    virtual void event(CEvent&) override;
+    virtual void event(Core::Event&) override;
 
     bool is_visible() const;
     bool is_active() const { return m_is_active; }
@@ -175,7 +175,7 @@ public:
     GAction* action_for_key_event(const GKeyEvent&);
 
 protected:
-    GWindow(CObject* parent = nullptr);
+    GWindow(Core::Object* parent = nullptr);
     virtual void wm_event(GWMEvent&);
 
 private:
@@ -216,7 +216,7 @@ private:
 };
 
 template<>
-inline bool is<GWindow>(const CObject& object)
+inline bool Core::is<GWindow>(const Core::Object& object)
 {
     return object.is_window();
 }
diff --git a/Libraries/LibGUI/GWindowServerConnection.cpp b/Libraries/LibGUI/GWindowServerConnection.cpp
index c8ac8c775f..c514e59a99 100644
--- a/Libraries/LibGUI/GWindowServerConnection.cpp
+++ b/Libraries/LibGUI/GWindowServerConnection.cpp
@@ -75,13 +75,13 @@ void GWindowServerConnection::handle(const WindowClient::Paint& message)
     dbgprintf("WID=%d Paint\n", message.window_id());
 #endif
     if (auto* window = GWindow::from_window_id(message.window_id()))
-        CEventLoop::current().post_event(*window, make<GMultiPaintEvent>(message.rects(), message.window_size()));
+        Core::EventLoop::current().post_event(*window, make<GMultiPaintEvent>(message.rects(), message.window_size()));
 }
 
 void GWindowServerConnection::handle(const WindowClient::WindowResized& message)
 {
     if (auto* window = GWindow::from_window_id(message.window_id())) {
-        CEventLoop::current().post_event(*window, make<GResizeEvent>(message.old_rect().size(), message.new_rect().size()));
+        Core::EventLoop::current().post_event(*window, make<GResizeEvent>(message.old_rect().size(), message.new_rect().size()));
     }
 }
 
@@ -91,7 +91,7 @@ void GWindowServerConnection::handle(const WindowClient::WindowActivated& messag
     dbgprintf("(%d) WID=%d WindowActivated\n", getpid(), message.window_id());
 #endif
     if (auto* window = GWindow::from_window_id(message.window_id()))
-        CEventLoop::current().post_event(*window, make<GEvent>(GEvent::WindowBecameActive));
+        Core::EventLoop::current().post_event(*window, make<GEvent>(GEvent::WindowBecameActive));
 }
 
 void GWindowServerConnection::handle(const WindowClient::WindowDeactivated& message)
@@ -100,25 +100,25 @@ void GWindowServerConnection::handle(const WindowClient::WindowDeactivated& mess
     dbgprintf("(%d) WID=%d WindowDeactivated\n", getpid(), message.window_id());
 #endif
     if (auto* window = GWindow::from_window_id(message.window_id()))
-        CEventLoop::current().post_event(*window, make<GEvent>(GEvent::WindowBecameInactive));
+        Core::EventLoop::current().post_event(*window, make<GEvent>(GEvent::WindowBecameInactive));
 }
 
 void GWindowServerConnection::handle(const WindowClient::WindowCloseRequest& message)
 {
     if (auto* window = GWindow::from_window_id(message.window_id()))
-        CEventLoop::current().post_event(*window, make<GEvent>(GEvent::WindowCloseRequest));
+        Core::EventLoop::current().post_event(*window, make<GEvent>(GEvent::WindowCloseRequest));
 }
 
 void GWindowServerConnection::handle(const WindowClient::WindowEntered& message)
 {
     if (auto* window = GWindow::from_window_id(message.window_id()))
-        CEventLoop::current().post_event(*window, make<GEvent>(GEvent::WindowEntered));
+        Core::EventLoop::current().post_event(*window, make<GEvent>(GEvent::WindowEntered));
 }
 
 void GWindowServerConnection::handle(const WindowClient::WindowLeft& message)
 {
     if (auto* window = GWindow::from_window_id(message.window_id()))
-        CEventLoop::current().post_event(*window, make<GEvent>(GEvent::WindowLeft));
+        Core::EventLoop::current().post_event(*window, make<GEvent>(GEvent::WindowLeft));
 }
 
 void GWindowServerConnection::handle(const WindowClient::KeyDown& message)
@@ -151,7 +151,7 @@ void GWindowServerConnection::handle(const WindowClient::KeyDown& message)
         action->activate();
         return;
     }
-    CEventLoop::current().post_event(*window, move(key_event));
+    Core::EventLoop::current().post_event(*window, move(key_event));
 }
 
 void GWindowServerConnection::handle(const WindowClient::KeyUp& message)
@@ -169,7 +169,7 @@ void GWindowServerConnection::handle(const WindowClient::KeyUp& message)
         key_event->m_text = String(&ch, 1);
     }
 
-    CEventLoop::current().post_event(*window, move(key_event));
+    Core::EventLoop::current().post_event(*window, move(key_event));
 }
 
 GMouseButton to_gmousebutton(u32 button)
@@ -196,7 +196,7 @@ void GWindowServerConnection::handle(const WindowClient::MouseDown& message)
 #endif
 
     if (auto* window = GWindow::from_window_id(message.window_id()))
-        CEventLoop::current().post_event(*window, make<GMouseEvent>(GEvent::MouseDown, message.mouse_position(), message.buttons(), to_gmousebutton(message.button()), message.modifiers(), message.wheel_delta()));
+        Core::EventLoop::current().post_event(*window, make<GMouseEvent>(GEvent::MouseDown, message.mouse_position(), message.buttons(), to_gmousebutton(message.button()), message.modifiers(), message.wheel_delta()));
 }
 
 void GWindowServerConnection::handle(const WindowClient::MouseUp& message)
@@ -206,7 +206,7 @@ void GWindowServerConnection::handle(const WindowClient::MouseUp& message)
 #endif
 
     if (auto* window = GWindow::from_window_id(message.window_id()))
-        CEventLoop::current().post_event(*window, make<GMouseEvent>(GEvent::MouseUp, message.mouse_position(), message.buttons(), to_gmousebutton(message.button()), message.modifiers(), message.wheel_delta()));
+        Core::EventLoop::current().post_event(*window, make<GMouseEvent>(GEvent::MouseUp, message.mouse_position(), message.buttons(), to_gmousebutton(message.button()), message.modifiers(), message.wheel_delta()));
 }
 
 void GWindowServerConnection::handle(const WindowClient::MouseMove& message)
@@ -216,7 +216,7 @@ void GWindowServerConnection::handle(const WindowClient::MouseMove& message)
 #endif
 
     if (auto* window = GWindow::from_window_id(message.window_id()))
-        CEventLoop::current().post_event(*window, make<GMouseEvent>(GEvent::MouseMove, message.mouse_position(), message.buttons(), to_gmousebutton(message.button()), message.modifiers(), message.wheel_delta()));
+        Core::EventLoop::current().post_event(*window, make<GMouseEvent>(GEvent::MouseMove, message.mouse_position(), message.buttons(), to_gmousebutton(message.button()), message.modifiers(), message.wheel_delta()));
 }
 
 void GWindowServerConnection::handle(const WindowClient::MouseDoubleClick& message)
@@ -226,7 +226,7 @@ void GWindowServerConnection::handle(const WindowClient::MouseDoubleClick& messa
 #endif
 
     if (auto* window = GWindow::from_window_id(message.window_id()))
-        CEventLoop::current().post_event(*window, make<GMouseEvent>(GEvent::MouseDoubleClick, message.mouse_position(), message.buttons(), to_gmousebutton(message.button()), message.modifiers(), message.wheel_delta()));
+        Core::EventLoop::current().post_event(*window, make<GMouseEvent>(GEvent::MouseDoubleClick, message.mouse_position(), message.buttons(), to_gmousebutton(message.button()), message.modifiers(), message.wheel_delta()));
 }
 
 void GWindowServerConnection::handle(const WindowClient::MouseWheel& message)
@@ -236,7 +236,7 @@ void GWindowServerConnection::handle(const WindowClient::MouseWheel& message)
 #endif
 
     if (auto* window = GWindow::from_window_id(message.window_id()))
-        CEventLoop::current().post_event(*window, make<GMouseEvent>(GEvent::MouseWheel, message.mouse_position(), message.buttons(), to_gmousebutton(message.button()), message.modifiers(), message.wheel_delta()));
+        Core::EventLoop::current().post_event(*window, make<GMouseEvent>(GEvent::MouseWheel, message.mouse_position(), message.buttons(), to_gmousebutton(message.button()), message.modifiers(), message.wheel_delta()));
 }
 
 void GWindowServerConnection::handle(const WindowClient::MenuItemActivated& message)
@@ -256,7 +256,7 @@ void GWindowServerConnection::handle(const WindowClient::WM_WindowStateChanged&
     dbgprintf("GEventLoop: handle_wm_event: %d\n", (int)event.type);
 #endif
     if (auto* window = GWindow::from_window_id(message.wm_id()))
-        CEventLoop::current().post_event(*window, make<GWMWindowStateChangedEvent>(message.client_id(), message.window_id(), message.title(), message.rect(), message.is_active(), (GWindowType)message.window_type(), message.is_minimized()));
+        Core::EventLoop::current().post_event(*window, make<GWMWindowStateChangedEvent>(message.client_id(), message.window_id(), message.title(), message.rect(), message.is_active(), (GWindowType)message.window_type(), message.is_minimized()));
 }
 
 void GWindowServerConnection::handle(const WindowClient::WM_WindowRectChanged& message)
@@ -265,7 +265,7 @@ void GWindowServerConnection::handle(const WindowClient::WM_WindowRectChanged& m
     dbgprintf("GEventLoop: handle_wm_event: %d\n", (int)event.type);
 #endif
     if (auto* window = GWindow::from_window_id(message.wm_id()))
-        CEventLoop::current().post_event(*window, make<GWMWindowRectChangedEvent>(message.client_id(), message.window_id(), message.rect()));
+        Core::EventLoop::current().post_event(*window, make<GWMWindowRectChangedEvent>(message.client_id(), message.window_id(), message.rect()));
 }
 
 void GWindowServerConnection::handle(const WindowClient::WM_WindowIconBitmapChanged& message)
@@ -274,7 +274,7 @@ void GWindowServerConnection::handle(const WindowClient::WM_WindowIconBitmapChan
     dbgprintf("GEventLoop: handle_wm_event: %d\n", (int)event.type);
 #endif
     if (auto* window = GWindow::from_window_id(message.wm_id()))
-        CEventLoop::current().post_event(*window, make<GWMWindowIconBitmapChangedEvent>(message.client_id(), message.window_id(), message.icon_buffer_id(), message.icon_size()));
+        Core::EventLoop::current().post_event(*window, make<GWMWindowIconBitmapChangedEvent>(message.client_id(), message.window_id(), message.icon_buffer_id(), message.icon_size()));
 }
 
 void GWindowServerConnection::handle(const WindowClient::WM_WindowRemoved& message)
@@ -283,7 +283,7 @@ void GWindowServerConnection::handle(const WindowClient::WM_WindowRemoved& messa
     dbgprintf("GEventLoop: handle_wm_event: %d\n", (int)event.type);
 #endif
     if (auto* window = GWindow::from_window_id(message.wm_id()))
-        CEventLoop::current().post_event(*window, make<GWMWindowRemovedEvent>(message.client_id(), message.window_id()));
+        Core::EventLoop::current().post_event(*window, make<GWMWindowRemovedEvent>(message.client_id(), message.window_id()));
 }
 
 void GWindowServerConnection::handle(const WindowClient::ScreenRectChanged& message)
@@ -304,7 +304,7 @@ void GWindowServerConnection::handle(const WindowClient::AsyncSetWallpaperFinish
 void GWindowServerConnection::handle(const WindowClient::DragDropped& message)
 {
     if (auto* window = GWindow::from_window_id(message.window_id()))
-        CEventLoop::current().post_event(*window, make<GDropEvent>(message.mouse_position(), message.text(), message.data_type(), message.data()));
+        Core::EventLoop::current().post_event(*window, make<GDropEvent>(message.mouse_position(), message.text(), message.data_type(), message.data()));
 }
 
 void GWindowServerConnection::handle(const WindowClient::DragAccepted&)
diff --git a/Libraries/LibHTML/CSS/StyleProperties.cpp b/Libraries/LibHTML/CSS/StyleProperties.cpp
index a7e10a087f..a2c3fe7b64 100644
--- a/Libraries/LibHTML/CSS/StyleProperties.cpp
+++ b/Libraries/LibHTML/CSS/StyleProperties.cpp
@@ -109,7 +109,7 @@ void StyleProperties::load_font() const
 
     auto look_for_file = [](const StringView& expected_name) -> String {
         // TODO: handle font sizes properly?
-        CDirIterator it { "/res/fonts/", CDirIterator::Flags::SkipDots };
+        Core::DirIterator it { "/res/fonts/", Core::DirIterator::Flags::SkipDots };
         while (it.has_next()) {
             String name = it.next_path();
             ASSERT(name.ends_with(".font"));
diff --git a/Libraries/LibHTML/CodeGenerators/Generate_CSS_PropertyID_cpp/Generate_CSS_PropertyID_cpp.cpp b/Libraries/LibHTML/CodeGenerators/Generate_CSS_PropertyID_cpp/Generate_CSS_PropertyID_cpp.cpp
index 173fa4ef84..ebcd2b60d9 100644
--- a/Libraries/LibHTML/CodeGenerators/Generate_CSS_PropertyID_cpp/Generate_CSS_PropertyID_cpp.cpp
+++ b/Libraries/LibHTML/CodeGenerators/Generate_CSS_PropertyID_cpp/Generate_CSS_PropertyID_cpp.cpp
@@ -51,8 +51,8 @@ int main(int argc, char** argv)
         fprintf(stderr, "usage: %s <path/to/CSS/Properties.json>\n", argv[0]);
         return 1;
     }
-    auto file = CFile::construct(argv[1]);
-    if (!file->open(CIODevice::ReadOnly))
+    auto file = Core::File::construct(argv[1]);
+    if (!file->open(Core::IODevice::ReadOnly))
         return 1;
 
     auto json = JsonValue::from_string(file->read_all());
diff --git a/Libraries/LibHTML/CodeGenerators/Generate_CSS_PropertyID_h/Generate_CSS_PropertyID_h.cpp b/Libraries/LibHTML/CodeGenerators/Generate_CSS_PropertyID_h/Generate_CSS_PropertyID_h.cpp
index 571f42fd12..0a53d66696 100644
--- a/Libraries/LibHTML/CodeGenerators/Generate_CSS_PropertyID_h/Generate_CSS_PropertyID_h.cpp
+++ b/Libraries/LibHTML/CodeGenerators/Generate_CSS_PropertyID_h/Generate_CSS_PropertyID_h.cpp
@@ -51,8 +51,8 @@ int main(int argc, char** argv)
         fprintf(stderr, "usage: %s <path/to/CSS/Properties.json>\n", argv[0]);
         return 1;
     }
-    auto file = CFile::construct(argv[1]);
-    if (!file->open(CIODevice::ReadOnly))
+    auto file = Core::File::construct(argv[1]);
+    if (!file->open(Core::IODevice::ReadOnly))
         return 1;
 
     auto json = JsonValue::from_string(file->read_all());
diff --git a/Libraries/LibHTML/DOM/Document.cpp b/Libraries/LibHTML/DOM/Document.cpp
index 9fdd86be36..e06d503554 100644
--- a/Libraries/LibHTML/DOM/Document.cpp
+++ b/Libraries/LibHTML/DOM/Document.cpp
@@ -47,7 +47,7 @@ Document::Document()
     : ParentNode(*this, NodeType::DOCUMENT_NODE)
     , m_style_resolver(make<StyleResolver>(*this))
 {
-    m_style_update_timer = CTimer::construct();
+    m_style_update_timer = Core::Timer::construct();
     m_style_update_timer->set_single_shot(true);
     m_style_update_timer->set_interval(0);
     m_style_update_timer->on_timeout = [this] {
diff --git a/Libraries/LibHTML/DOM/Document.h b/Libraries/LibHTML/DOM/Document.h
index dc781a25c6..49bef5168b 100644
--- a/Libraries/LibHTML/DOM/Document.h
+++ b/Libraries/LibHTML/DOM/Document.h
@@ -36,8 +36,11 @@
 #include <LibHTML/CSS/StyleSheet.h>
 #include <LibHTML/DOM/ParentNode.h>
 
+namespace Core {
+class Timer;
+}
+
 class Palette;
-class CTimer;
 class Frame;
 class HTMLBodyElement;
 class HTMLHtmlElement;
@@ -135,7 +138,7 @@ private:
     Optional<Color> m_active_link_color;
     Optional<Color> m_visited_link_color;
 
-    RefPtr<CTimer> m_style_update_timer;
+    RefPtr<Core::Timer> m_style_update_timer;
 
     String m_source;
 };
diff --git a/Libraries/LibHTML/DOM/HTMLBlinkElement.cpp b/Libraries/LibHTML/DOM/HTMLBlinkElement.cpp
index ff174eaac6..26d4ac6b71 100644
--- a/Libraries/LibHTML/DOM/HTMLBlinkElement.cpp
+++ b/Libraries/LibHTML/DOM/HTMLBlinkElement.cpp
@@ -32,7 +32,7 @@
 
 HTMLBlinkElement::HTMLBlinkElement(Document& document, const String& tag_name)
     : HTMLElement(document, tag_name)
-    , m_timer(CTimer::construct())
+    , m_timer(Core::Timer::construct())
 {
     m_timer->set_interval(500);
     m_timer->on_timeout = [this] { blink(); };
diff --git a/Libraries/LibHTML/DOM/HTMLBlinkElement.h b/Libraries/LibHTML/DOM/HTMLBlinkElement.h
index a673d81c36..8e9594bbf3 100644
--- a/Libraries/LibHTML/DOM/HTMLBlinkElement.h
+++ b/Libraries/LibHTML/DOM/HTMLBlinkElement.h
@@ -28,7 +28,9 @@
 
 #include <LibHTML/DOM/HTMLElement.h>
 
-class CTimer;
+namespace Core {
+class Timer;
+}
 
 class HTMLBlinkElement : public HTMLElement {
 public:
@@ -38,5 +40,5 @@ public:
 private:
     void blink();
 
-    NonnullRefPtr<CTimer> m_timer;
+    NonnullRefPtr<Core::Timer> m_timer;
 };
diff --git a/Libraries/LibHTML/ResourceLoader.cpp b/Libraries/LibHTML/ResourceLoader.cpp
index 759144c9ad..6aabe84732 100644
--- a/Libraries/LibHTML/ResourceLoader.cpp
+++ b/Libraries/LibHTML/ResourceLoader.cpp
@@ -46,9 +46,9 @@ ResourceLoader::ResourceLoader()
 void ResourceLoader::load(const URL& url, Function<void(const ByteBuffer&)> callback)
 {
     if (url.protocol() == "file") {
-        auto f = CFile::construct();
+        auto f = Core::File::construct();
         f->set_filename(url.path());
-        if (!f->open(CIODevice::OpenMode::ReadOnly)) {
+        if (!f->open(Core::IODevice::OpenMode::ReadOnly)) {
             dbg() << "ResourceLoader::load: Error: " << f->error_string();
             callback({});
             return;
diff --git a/Libraries/LibHTML/ResourceLoader.h b/Libraries/LibHTML/ResourceLoader.h
index 62fff3f89b..ef634deea2 100644
--- a/Libraries/LibHTML/ResourceLoader.h
+++ b/Libraries/LibHTML/ResourceLoader.h
@@ -34,7 +34,7 @@ namespace LibProtocol {
 class Client;
 }
 
-class ResourceLoader : public CObject {
+class ResourceLoader : public Core::Object {
     C_OBJECT(ResourceLoader)
 public:
     static ResourceLoader& the();
diff --git a/Libraries/LibIPC/IClientConnection.h b/Libraries/LibIPC/IClientConnection.h
index e20219cbbb..7542d7b78c 100644
--- a/Libraries/LibIPC/IClientConnection.h
+++ b/Libraries/LibIPC/IClientConnection.h
@@ -40,7 +40,7 @@
 #include <sys/types.h>
 #include <unistd.h>
 
-class IEvent : public CEvent {
+class IEvent : public Core::Event {
 public:
     enum Type {
         Invalid = 2000,
@@ -48,7 +48,7 @@ public:
     };
     IEvent() {}
     explicit IEvent(Type type)
-        : CEvent(type)
+        : Core::Event(type)
     {
     }
 };
@@ -74,9 +74,9 @@ NonnullRefPtr<T> new_client_connection(Args&&... args)
 }
 
 template<typename Endpoint>
-class IClientConnection : public CObject {
+class IClientConnection : public Core::Object {
 public:
-    IClientConnection(Endpoint& endpoint, CLocalSocket& socket, int client_id)
+    IClientConnection(Endpoint& endpoint, Core::LocalSocket& socket, int client_id)
         : m_endpoint(endpoint)
         , m_socket(socket)
         , m_client_id(client_id)
@@ -133,7 +133,7 @@ public:
             ssize_t nread = recv(m_socket->fd(), buffer, sizeof(buffer), MSG_DONTWAIT);
             if (nread == 0 || (nread == -1 && errno == EAGAIN)) {
                 if (bytes.is_empty()) {
-                    CEventLoop::current().post_event(*this, make<IDisconnectedEvent>(client_id()));
+                    Core::EventLoop::current().post_event(*this, make<IDisconnectedEvent>(client_id()));
                     return;
                 }
                 break;
@@ -184,7 +184,7 @@ public:
     virtual void die() = 0;
 
 protected:
-    void event(CEvent& event) override
+    void event(Core::Event& event) override
     {
         if (event.type() == IEvent::Disconnected) {
             int client_id = static_cast<const IDisconnectedEvent&>(event).client_id();
@@ -193,12 +193,12 @@ protected:
             return;
         }
 
-        CObject::event(event);
+        Core::Object::event(event);
     }
 
 private:
     Endpoint& m_endpoint;
-    RefPtr<CLocalSocket> m_socket;
+    RefPtr<Core::LocalSocket> m_socket;
     int m_client_id { -1 };
     int m_client_pid { -1 };
 };
diff --git a/Libraries/LibIPC/IServerConnection.h b/Libraries/LibIPC/IServerConnection.h
index 31b7ce7f56..90dfbe7730 100644
--- a/Libraries/LibIPC/IServerConnection.h
+++ b/Libraries/LibIPC/IServerConnection.h
@@ -41,12 +41,12 @@
 #include <unistd.h>
 
 template<typename LocalEndpoint, typename PeerEndpoint>
-class IServerConnection : public CObject {
+class IServerConnection : public Core::Object {
 public:
     IServerConnection(LocalEndpoint& local_endpoint, const StringView& address)
         : m_local_endpoint(local_endpoint)
-        , m_connection(CLocalSocket::construct(this))
-        , m_notifier(CNotifier::construct(m_connection->fd(), CNotifier::Read, this))
+        , m_connection(Core::LocalSocket::construct(this))
+        , m_notifier(Core::Notifier::construct(m_connection->fd(), Core::Notifier::Read, this))
     {
         // We want to rate-limit our clients
         m_connection->set_blocking(true);
@@ -57,7 +57,7 @@ public:
 
         int retries = 100000;
         while (retries) {
-            if (m_connection->connect(CSocketAddress::local(address))) {
+            if (m_connection->connect(Core::SocketAddress::local(address))) {
                 break;
             }
 
@@ -193,8 +193,8 @@ private:
     }
 
     LocalEndpoint& m_local_endpoint;
-    RefPtr<CLocalSocket> m_connection;
-    RefPtr<CNotifier> m_notifier;
+    RefPtr<Core::LocalSocket> m_connection;
+    RefPtr<Core::Notifier> m_notifier;
     Vector<OwnPtr<IMessage>> m_unprocessed_messages;
     int m_server_pid { -1 };
     int m_my_client_id { -1 };
diff --git a/Libraries/LibThread/BackgroundAction.h b/Libraries/LibThread/BackgroundAction.h
index 44cece2b75..35d39d3724 100644
--- a/Libraries/LibThread/BackgroundAction.h
+++ b/Libraries/LibThread/BackgroundAction.h
@@ -52,14 +52,14 @@ private:
 };
 
 template<typename Result>
-class BackgroundAction final : public CObject
+class BackgroundAction final : public Core::Object
     , private BackgroundActionBase {
     C_OBJECT(BackgroundAction);
+
 public:
     static NonnullRefPtr<BackgroundAction<Result>> create(
         Function<Result()> action,
-        Function<void(Result)> on_complete = nullptr
-    )
+        Function<void(Result)> on_complete = nullptr)
     {
         return adopt(*new BackgroundAction(move(action), move(on_complete)));
     }
@@ -67,9 +67,8 @@ public:
     virtual ~BackgroundAction() {}
 
 private:
-
     BackgroundAction(Function<Result()> action, Function<void(Result)> on_complete)
-        : CObject(&background_thread())
+        : Core::Object(&background_thread())
         , m_action(move(action))
         , m_on_complete(move(on_complete))
     {
@@ -79,11 +78,11 @@ private:
         all_actions().resource().enqueue([this] {
             m_result = m_action();
             if (m_on_complete) {
-                CEventLoop::main().post_event(*this, make<CDeferredInvocationEvent>([this](CObject&) {
+                Core::EventLoop::main().post_event(*this, make<Core::DeferredInvocationEvent>([this](auto&) {
                     m_on_complete(m_result.release_value());
                     this->unref();
                 }));
-                CEventLoop::main().wake();
+                Core::EventLoop::main().wake();
             } else
                 this->unref();
         });
diff --git a/Libraries/LibThread/Thread.cpp b/Libraries/LibThread/Thread.cpp
index 26ee7a4d6a..2e1475ff25 100644
--- a/Libraries/LibThread/Thread.cpp
+++ b/Libraries/LibThread/Thread.cpp
@@ -29,7 +29,7 @@
 #include <unistd.h>
 
 LibThread::Thread::Thread(Function<int()> action, StringView thread_name)
-    : CObject(nullptr)
+    : Core::Object(nullptr)
     , m_action(move(action))
     , m_thread_name(thread_name.is_null() ? "" : thread_name)
 {
diff --git a/Libraries/LibThread/Thread.h b/Libraries/LibThread/Thread.h
index 12db8bda84..474a17fa42 100644
--- a/Libraries/LibThread/Thread.h
+++ b/Libraries/LibThread/Thread.h
@@ -32,7 +32,7 @@
 
 namespace LibThread {
 
-class Thread final : public CObject {
+class Thread final : public Core::Object {
     C_OBJECT(Thread);
 
 public:
diff --git a/Libraries/LibVT/TerminalWidget.cpp b/Libraries/LibVT/TerminalWidget.cpp
index 50e9f2ec13..933c8be176 100644
--- a/Libraries/LibVT/TerminalWidget.cpp
+++ b/Libraries/LibVT/TerminalWidget.cpp
@@ -54,7 +54,7 @@ void TerminalWidget::set_pty_master_fd(int fd)
         m_notifier = nullptr;
         return;
     }
-    m_notifier = CNotifier::construct(m_ptm_fd, CNotifier::Read);
+    m_notifier = Core::Notifier::construct(m_ptm_fd, Core::Notifier::Read);
     m_notifier->on_ready_to_read = [this] {
         u8 buffer[BUFSIZ];
         ssize_t nread = read(m_ptm_fd, buffer, sizeof(buffer));
@@ -81,14 +81,14 @@ void TerminalWidget::set_pty_master_fd(int fd)
     };
 }
 
-TerminalWidget::TerminalWidget(int ptm_fd, bool automatic_size_policy, RefPtr<CConfigFile> config)
+TerminalWidget::TerminalWidget(int ptm_fd, bool automatic_size_policy, RefPtr<Core::ConfigFile> config)
     : m_terminal(*this)
     , m_automatic_size_policy(automatic_size_policy)
     , m_config(move(config))
 {
     set_pty_master_fd(ptm_fd);
-    m_cursor_blink_timer = CTimer::construct();
-    m_visual_beep_timer = CTimer::construct();
+    m_cursor_blink_timer = Core::Timer::construct();
+    m_visual_beep_timer = Core::Timer::construct();
 
     set_frame_shape(FrameShape::Container);
     set_frame_shadow(FrameShadow::Sunken);
@@ -165,19 +165,19 @@ void TerminalWidget::set_logical_focus(bool focus)
     update();
 }
 
-void TerminalWidget::focusin_event(CEvent& event)
+void TerminalWidget::focusin_event(Core::Event& event)
 {
     set_logical_focus(true);
     return GFrame::focusin_event(event);
 }
 
-void TerminalWidget::focusout_event(CEvent& event)
+void TerminalWidget::focusout_event(Core::Event& event)
 {
     set_logical_focus(false);
     return GFrame::focusout_event(event);
 }
 
-void TerminalWidget::event(CEvent& event)
+void TerminalWidget::event(Core::Event& event)
 {
     if (event.type() == GEvent::WindowBecameActive)
         set_logical_focus(true);
diff --git a/Libraries/LibVT/TerminalWidget.h b/Libraries/LibVT/TerminalWidget.h
index fcd4adeedb..abae678816 100644
--- a/Libraries/LibVT/TerminalWidget.h
+++ b/Libraries/LibVT/TerminalWidget.h
@@ -41,7 +41,7 @@ class TerminalWidget final : public GFrame
     , public VT::TerminalClient {
     C_OBJECT(TerminalWidget)
 public:
-    TerminalWidget(int ptm_fd, bool automatic_size_policy, RefPtr<CConfigFile> config);
+    TerminalWidget(int ptm_fd, bool automatic_size_policy, RefPtr<Core::ConfigFile> config);
     virtual ~TerminalWidget() override;
 
     void set_pty_master_fd(int fd);
@@ -65,7 +65,7 @@ public:
     bool should_beep() { return m_should_beep; }
     void set_should_beep(bool sb) { m_should_beep = sb; };
 
-    RefPtr<CConfigFile> config() const { return m_config; }
+    RefPtr<Core::ConfigFile> config() const { return m_config; }
 
     bool has_selection() const;
     bool selection_contains(const VT::Position&) const;
@@ -89,7 +89,7 @@ public:
 
 private:
     // ^GWidget
-    virtual void event(CEvent&) override;
+    virtual void event(Core::Event&) override;
     virtual void paint_event(GPaintEvent&) override;
     virtual void resize_event(GResizeEvent&) override;
     virtual void keydown_event(GKeyEvent&) override;
@@ -97,8 +97,8 @@ private:
     virtual void mousemove_event(GMouseEvent&) override;
     virtual void mousewheel_event(GMouseEvent&) override;
     virtual void doubleclick_event(GMouseEvent&) override;
-    virtual void focusin_event(CEvent&) override;
-    virtual void focusout_event(CEvent&) override;
+    virtual void focusin_event(Core::Event&) override;
+    virtual void focusout_event(Core::Event&) override;
     virtual void context_menu_event(GContextMenuEvent&) override;
     virtual void drop_event(GDropEvent&) override;
     virtual void did_change_font() override;
@@ -143,7 +143,7 @@ private:
 
     bool m_has_logical_focus { false };
 
-    RefPtr<CNotifier> m_notifier;
+    RefPtr<Core::Notifier> m_notifier;
 
     u8 m_opacity { 255 };
     bool m_needs_background_fill { true };
@@ -154,9 +154,9 @@ private:
 
     int m_glyph_width { 0 };
 
-    RefPtr<CTimer> m_cursor_blink_timer;
-    RefPtr<CTimer> m_visual_beep_timer;
-    RefPtr<CConfigFile> m_config;
+    RefPtr<Core::Timer> m_cursor_blink_timer;
+    RefPtr<Core::Timer> m_visual_beep_timer;
+    RefPtr<Core::ConfigFile> m_config;
 
     RefPtr<GScrollBar> m_scrollbar;
 
@@ -165,5 +165,5 @@ private:
 
     RefPtr<GMenu> m_context_menu;
 
-    CElapsedTimer m_triple_click_timer;
+    Core::ElapsedTimer m_triple_click_timer;
 };