diff --git a/Kernel/ProcFileSystem.cpp b/Kernel/ProcFileSystem.cpp
index ea1ba1353b..645a36e8fa 100644
--- a/Kernel/ProcFileSystem.cpp
+++ b/Kernel/ProcFileSystem.cpp
@@ -6,25 +6,25 @@
 #include "StdLib.h"
 #include "i386.h"
 
-static ProcFileSystem* s_the;
+static ProcFS* s_the;
 
-ProcFileSystem& ProcFileSystem::the()
+ProcFS& ProcFS::the()
 {
     ASSERT(s_the);
     return *s_the;
 }
 
-RetainPtr<ProcFileSystem> ProcFileSystem::create()
+RetainPtr<ProcFS> ProcFS::create()
 {
-    return adopt(*new ProcFileSystem);
+    return adopt(*new ProcFS);
 }
 
-ProcFileSystem::ProcFileSystem()
+ProcFS::ProcFS()
 {
     s_the = this;
 }
 
-ProcFileSystem::~ProcFileSystem()
+ProcFS::~ProcFS()
 {
 }
 
@@ -147,7 +147,7 @@ ByteBuffer procfs$pid_cwd(Process& process)
     return VFS::the().absolute_path(*inode).toByteBuffer();
 }
 
-void ProcFileSystem::addProcess(Process& process)
+void ProcFS::addProcess(Process& process)
 {
     InterruptDisabler disabler;
     char buf[16];
@@ -163,7 +163,7 @@ void ProcFileSystem::addProcess(Process& process)
     addFile(create_generated_file("cwd", [&process] { return procfs$pid_cwd(process); }, 00120777), dir.index());
 }
 
-void ProcFileSystem::removeProcess(Process& process)
+void ProcFS::removeProcess(Process& process)
 {
     InterruptDisabler disabler;
     auto pid = process.pid();
@@ -354,9 +354,9 @@ ByteBuffer procfs$vnodes()
     return buffer;
 }
 
-bool ProcFileSystem::initialize()
+bool ProcFS::initialize()
 {
-    SyntheticFileSystem::initialize();
+    SynthFS::initialize();
     addFile(create_generated_file("mm", procfs$mm));
     addFile(create_generated_file("regions", procfs$regions));
     addFile(create_generated_file("mounts", procfs$mounts));
@@ -367,7 +367,7 @@ bool ProcFileSystem::initialize()
     return true;
 }
 
-const char* ProcFileSystem::class_name() const
+const char* ProcFS::class_name() const
 {
     return "procfs";
 }
diff --git a/Kernel/ProcFileSystem.h b/Kernel/ProcFileSystem.h
index 9541faa092..f9169f9e3e 100644
--- a/Kernel/ProcFileSystem.h
+++ b/Kernel/ProcFileSystem.h
@@ -5,12 +5,12 @@
 
 class Process;
 
-class ProcFileSystem final : public SyntheticFileSystem {
+class ProcFS final : public SynthFS {
 public:
-    static ProcFileSystem& the() PURE;
+    static ProcFS& the() PURE;
 
-    virtual ~ProcFileSystem() override;
-    static RetainPtr<ProcFileSystem> create();
+    virtual ~ProcFS() override;
+    static RetainPtr<ProcFS> create();
 
     virtual bool initialize() override;
     virtual const char* class_name() const override;
@@ -19,7 +19,7 @@ public:
     void removeProcess(Process&);
 
 private:
-    ProcFileSystem();
+    ProcFS();
 
     HashMap<pid_t, InodeIndex> m_pid2inode;
 };
diff --git a/Kernel/Process.cpp b/Kernel/Process.cpp
index 6ec78994f3..3df32e6abb 100644
--- a/Kernel/Process.cpp
+++ b/Kernel/Process.cpp
@@ -274,7 +274,7 @@ Process* Process::fork(RegisterDump& regs)
     dbgprintf("fork: child will begin executing at %w:%x with stack %w:%x\n", child->m_tss.cs, child->m_tss.eip, child->m_tss.ss, child->m_tss.esp);
 #endif
 
-    ProcFileSystem::the().addProcess(*child);
+    ProcFS::the().addProcess(*child);
 
     {
         InterruptDisabler disabler;
@@ -498,7 +498,7 @@ Process* Process::create_user_process(const String& path, uid_t uid, gid_t gid,
     if (error != 0)
         return nullptr;
 
-    ProcFileSystem::the().addProcess(*process);
+    ProcFS::the().addProcess(*process);
 
     {
         InterruptDisabler disabler;
@@ -561,7 +561,7 @@ Process* Process::create_kernel_process(void (*e)(), String&& name)
             g_processes->prepend(process);
             system.nprocess++;
         }
-        ProcFileSystem::the().addProcess(*process);
+        ProcFS::the().addProcess(*process);
 #ifdef TASK_DEBUG
         kprintf("Kernel process %u (%s) spawned @ %p\n", process->pid(), process->name().characters(), process->m_tss.eip);
 #endif
@@ -691,7 +691,7 @@ Process::Process(String&& name, uid_t uid, gid_t gid, pid_t ppid, RingLevel ring
 Process::~Process()
 {
     InterruptDisabler disabler;
-    ProcFileSystem::the().removeProcess(*this);
+    ProcFS::the().removeProcess(*this);
     system.nprocess--;
 
     gdt_free_entry(selector());
diff --git a/Kernel/init.cpp b/Kernel/init.cpp
index c36f4c1ba5..5e88b197c6 100644
--- a/Kernel/init.cpp
+++ b/Kernel/init.cpp
@@ -195,7 +195,7 @@ static void init_stage2()
     vfs->register_character_device(*tty3);
 
     auto dev_hd0 = IDEDiskDevice::create();
-    auto e2fs = Ext2FileSystem::create(dev_hd0.copyRef());
+    auto e2fs = Ext2FS::create(dev_hd0.copyRef());
     e2fs->initialize();
 
     vfs->mount_root(e2fs.copyRef());
@@ -214,7 +214,7 @@ static void init_stage2()
     }
 #endif
 
-    vfs->mount(ProcFileSystem::the(), "/proc");
+    vfs->mount(ProcFS::the(), "/proc");
 
     Vector<String> environment;
     environment.append("TERM=ansi");
@@ -280,7 +280,7 @@ void init()
     kprintf("%u kB base memory\n", base_memory);
     kprintf("%u kB extended memory\n", ext_memory);
 
-    auto procfs = ProcFileSystem::create();
+    auto procfs = ProcFS::create();
     procfs->initialize();
 
     Process::initialize();
diff --git a/VirtualFileSystem/DiskBackedFileSystem.cpp b/VirtualFileSystem/DiskBackedFileSystem.cpp
index 9cefbaacfd..ac776267af 100644
--- a/VirtualFileSystem/DiskBackedFileSystem.cpp
+++ b/VirtualFileSystem/DiskBackedFileSystem.cpp
@@ -9,17 +9,17 @@ typedef int InterruptDisabler;
 //#define DBFS_DEBUG
 #define BLOCK_CACHE
 
-DiskBackedFileSystem::DiskBackedFileSystem(RetainPtr<DiskDevice>&& device)
+DiskBackedFS::DiskBackedFS(RetainPtr<DiskDevice>&& device)
     : m_device(move(device))
 {
     ASSERT(m_device);
 }
 
-DiskBackedFileSystem::~DiskBackedFileSystem()
+DiskBackedFS::~DiskBackedFS()
 {
 }
 
-bool DiskBackedFileSystem::writeBlock(unsigned index, const ByteBuffer& data)
+bool DiskBackedFS::writeBlock(unsigned index, const ByteBuffer& data)
 {
     ASSERT(data.size() == blockSize());
 #ifdef DBFS_DEBUG
@@ -29,7 +29,7 @@ bool DiskBackedFileSystem::writeBlock(unsigned index, const ByteBuffer& data)
     return device().write(baseOffset, blockSize(), data.pointer());
 }
 
-bool DiskBackedFileSystem::writeBlocks(unsigned index, unsigned count, const ByteBuffer& data)
+bool DiskBackedFS::writeBlocks(unsigned index, unsigned count, const ByteBuffer& data)
 {
 #ifdef DBFS_DEBUG
     kprintf("DiskBackedFileSystem::writeBlocks %u x%u\n", index, count);
@@ -38,7 +38,7 @@ bool DiskBackedFileSystem::writeBlocks(unsigned index, unsigned count, const Byt
     return device().write(baseOffset, count * blockSize(), data.pointer());
 }
 
-ByteBuffer DiskBackedFileSystem::readBlock(unsigned index) const
+ByteBuffer DiskBackedFS::readBlock(unsigned index) const
 {
 #ifdef DBFS_DEBUG
     kprintf("DiskBackedFileSystem::readBlock %u\n", index);
@@ -75,7 +75,7 @@ ByteBuffer DiskBackedFileSystem::readBlock(unsigned index) const
     return buffer;
 }
 
-ByteBuffer DiskBackedFileSystem::readBlocks(unsigned index, unsigned count) const
+ByteBuffer DiskBackedFS::readBlocks(unsigned index, unsigned count) const
 {
     if (!count)
         return nullptr;
@@ -95,7 +95,7 @@ ByteBuffer DiskBackedFileSystem::readBlocks(unsigned index, unsigned count) cons
     return blocks;
 }
 
-void DiskBackedFileSystem::setBlockSize(unsigned blockSize)
+void DiskBackedFS::setBlockSize(unsigned blockSize)
 {
     if (blockSize == m_blockSize)
         return;
@@ -103,7 +103,7 @@ void DiskBackedFileSystem::setBlockSize(unsigned blockSize)
     invalidateCaches();
 }
 
-void DiskBackedFileSystem::invalidateCaches()
+void DiskBackedFS::invalidateCaches()
 {
     LOCKER(m_blockCacheLock);
     InterruptDisabler disabler;
diff --git a/VirtualFileSystem/DiskBackedFileSystem.h b/VirtualFileSystem/DiskBackedFileSystem.h
index 47c3322837..934917e96b 100644
--- a/VirtualFileSystem/DiskBackedFileSystem.h
+++ b/VirtualFileSystem/DiskBackedFileSystem.h
@@ -5,9 +5,9 @@
 #include <AK/HashMap.h>
 #include <AK/Lock.h>
 
-class DiskBackedFileSystem : public FileSystem {
+class DiskBackedFS : public FS {
 public:
-    virtual ~DiskBackedFileSystem() override;
+    virtual ~DiskBackedFS() override;
 
     DiskDevice& device() { return *m_device; }
     const DiskDevice& device() const { return *m_device; }
@@ -15,7 +15,7 @@ public:
     unsigned blockSize() const { return m_blockSize; }
 
 protected:
-    explicit DiskBackedFileSystem(RetainPtr<DiskDevice>&&);
+    explicit DiskBackedFS(RetainPtr<DiskDevice>&&);
 
     void setBlockSize(unsigned);
     void invalidateCaches();
diff --git a/VirtualFileSystem/Ext2FileSystem.cpp b/VirtualFileSystem/Ext2FileSystem.cpp
index 564937f019..fb292beb32 100644
--- a/VirtualFileSystem/Ext2FileSystem.cpp
+++ b/VirtualFileSystem/Ext2FileSystem.cpp
@@ -11,14 +11,14 @@
 
 //#define EXT2_DEBUG
 
-class Ext2FileSystem::CachedExt2InodeImpl : public Retainable<CachedExt2InodeImpl> {
+class Ext2FS::CachedExt2InodeImpl : public Retainable<CachedExt2InodeImpl> {
 public:
     CachedExt2InodeImpl(OwnPtr<ext2_inode>&& e2i) : e2inode(move(e2i)) { }
     ~CachedExt2InodeImpl() { }
     OwnPtr<ext2_inode> e2inode;
 };
 
-class Ext2FileSystem::CachedExt2Inode {
+class Ext2FS::CachedExt2Inode {
 public:
     const ext2_inode* operator->() const { return ptr->e2inode.ptr(); }
     const ext2_inode& operator*() const { return *ptr->e2inode; }
@@ -36,21 +36,21 @@ public:
     RetainPtr<CachedExt2InodeImpl> ptr;
 };
 
-RetainPtr<Ext2FileSystem> Ext2FileSystem::create(RetainPtr<DiskDevice>&& device)
+RetainPtr<Ext2FS> Ext2FS::create(RetainPtr<DiskDevice>&& device)
 {
-    return adopt(*new Ext2FileSystem(move(device)));
+    return adopt(*new Ext2FS(move(device)));
 }
 
-Ext2FileSystem::Ext2FileSystem(RetainPtr<DiskDevice>&& device)
-    : DiskBackedFileSystem(move(device))
+Ext2FS::Ext2FS(RetainPtr<DiskDevice>&& device)
+    : DiskBackedFS(move(device))
 {
 }
 
-Ext2FileSystem::~Ext2FileSystem()
+Ext2FS::~Ext2FS()
 {
 }
 
-ByteBuffer Ext2FileSystem::readSuperBlock() const
+ByteBuffer Ext2FS::readSuperBlock() const
 {
     auto buffer = ByteBuffer::createUninitialized(1024);
     device().readBlock(2, buffer.pointer());
@@ -58,7 +58,7 @@ ByteBuffer Ext2FileSystem::readSuperBlock() const
     return buffer;
 }
 
-bool Ext2FileSystem::writeSuperBlock(const ext2_super_block& sb)
+bool Ext2FS::writeSuperBlock(const ext2_super_block& sb)
 {
     const byte* raw = (const byte*)&sb;
     bool success;
@@ -71,19 +71,19 @@ bool Ext2FileSystem::writeSuperBlock(const ext2_super_block& sb)
     return true;
 }
 
-unsigned Ext2FileSystem::firstBlockOfGroup(unsigned groupIndex) const
+unsigned Ext2FS::firstBlockOfGroup(unsigned groupIndex) const
 {
     return superBlock().s_first_data_block + (groupIndex * superBlock().s_blocks_per_group);
 }
 
-const ext2_super_block& Ext2FileSystem::superBlock() const
+const ext2_super_block& Ext2FS::superBlock() const
 {
     if (!m_cachedSuperBlock)
         m_cachedSuperBlock = readSuperBlock();
     return *reinterpret_cast<ext2_super_block*>(m_cachedSuperBlock.pointer());
 }
 
-const ext2_group_desc& Ext2FileSystem::blockGroupDescriptor(unsigned groupIndex) const
+const ext2_group_desc& Ext2FS::blockGroupDescriptor(unsigned groupIndex) const
 {
     // FIXME: Should this fail gracefully somehow?
     ASSERT(groupIndex <= m_blockGroupCount);
@@ -100,7 +100,7 @@ const ext2_group_desc& Ext2FileSystem::blockGroupDescriptor(unsigned groupIndex)
     return reinterpret_cast<ext2_group_desc*>(m_cachedBlockGroupDescriptorTable.pointer())[groupIndex - 1];
 }
 
-bool Ext2FileSystem::initialize()
+bool Ext2FS::initialize()
 {
     auto& superBlock = this->superBlock();
 #ifdef EXT2_DEBUG
@@ -146,12 +146,12 @@ bool Ext2FileSystem::initialize()
     return true;
 }
 
-const char* Ext2FileSystem::class_name() const
+const char* Ext2FS::class_name() const
 {
     return "ext2fs";
 }
 
-InodeIdentifier Ext2FileSystem::rootInode() const
+InodeIdentifier Ext2FS::rootInode() const
 {
     return { id(), EXT2_ROOT_INO };
 }
@@ -168,7 +168,7 @@ static void dumpExt2Inode(const ext2_inode& inode)
 }
 #endif
 
-ByteBuffer Ext2FileSystem::readBlockContainingInode(unsigned inode, unsigned& blockIndex, unsigned& offset) const
+ByteBuffer Ext2FS::readBlockContainingInode(unsigned inode, unsigned& blockIndex, unsigned& offset) const
 {
     auto& superBlock = this->superBlock();
 
@@ -187,7 +187,7 @@ ByteBuffer Ext2FileSystem::readBlockContainingInode(unsigned inode, unsigned& bl
     return readBlock(blockIndex);
 }
 
-auto Ext2FileSystem::lookupExt2Inode(unsigned inode) const -> CachedExt2Inode
+auto Ext2FS::lookupExt2Inode(unsigned inode) const -> CachedExt2Inode
 {
     {
         LOCKER(m_inodeCacheLock);
@@ -218,7 +218,7 @@ auto Ext2FileSystem::lookupExt2Inode(unsigned inode) const -> CachedExt2Inode
     return CachedExt2Inode{ cachedInode };
 }
 
-InodeMetadata Ext2FileSystem::inodeMetadata(InodeIdentifier inode) const
+InodeMetadata Ext2FS::inodeMetadata(InodeIdentifier inode) const
 {
     ASSERT(inode.fsid() == id());
 
@@ -249,7 +249,7 @@ InodeMetadata Ext2FileSystem::inodeMetadata(InodeIdentifier inode) const
     return metadata;
 }
 
-Vector<unsigned> Ext2FileSystem::blockListForInode(const ext2_inode& e2inode) const
+Vector<unsigned> Ext2FS::blockListForInode(const ext2_inode& e2inode) const
 {
     unsigned entriesPerBlock = EXT2_ADDR_PER_BLOCK(&superBlock());
 
@@ -310,17 +310,17 @@ Vector<unsigned> Ext2FileSystem::blockListForInode(const ext2_inode& e2inode) co
     return list;
 }
 
-Ext2Inode::Ext2Inode(Ext2FileSystem& fs, unsigned index, const ext2_inode& raw_inode)
+Ext2FSInode::Ext2FSInode(Ext2FS& fs, unsigned index, const ext2_inode& raw_inode)
     : CoreInode(fs, index)
     , m_raw_inode(raw_inode)
 {
 }
 
-Ext2Inode::~Ext2Inode()
+Ext2FSInode::~Ext2FSInode()
 {
 }
 
-void Ext2Inode::populate_metadata() const
+void Ext2FSInode::populate_metadata() const
 {
     m_metadata.inode = identifier();
     m_metadata.size = m_raw_inode.i_size;
@@ -342,7 +342,7 @@ void Ext2Inode::populate_metadata() const
     }
 }
 
-RetainPtr<CoreInode> Ext2FileSystem::get_inode(InodeIdentifier inode) const
+RetainPtr<CoreInode> Ext2FS::get_inode(InodeIdentifier inode) const
 {
     ASSERT(inode.fsid() == id());
     {
@@ -358,12 +358,12 @@ RetainPtr<CoreInode> Ext2FileSystem::get_inode(InodeIdentifier inode) const
     auto it = m_inode_cache.find(inode.index());
     if (it != m_inode_cache.end())
         return (*it).value;
-    auto new_inode = adopt(*new Ext2Inode(const_cast<Ext2FileSystem&>(*this), inode.index(), *raw_inode));
+    auto new_inode = adopt(*new Ext2FSInode(const_cast<Ext2FS&>(*this), inode.index(), *raw_inode));
     m_inode_cache.set(inode.index(), new_inode.copyRef());
     return new_inode;
 }
 
-Unix::ssize_t Ext2Inode::read_bytes(Unix::off_t offset, Unix::size_t count, byte* buffer, FileDescriptor*)
+Unix::ssize_t Ext2FSInode::read_bytes(Unix::off_t offset, Unix::size_t count, byte* buffer, FileDescriptor*)
 {
     ASSERT(offset >= 0);
     if (m_raw_inode.i_size == 0)
@@ -425,7 +425,7 @@ Unix::ssize_t Ext2Inode::read_bytes(Unix::off_t offset, Unix::size_t count, byte
     return nread;
 }
 
-Unix::ssize_t Ext2FileSystem::read_inode_bytes(InodeIdentifier inode, Unix::off_t offset, Unix::size_t count, byte* buffer, FileDescriptor*) const
+Unix::ssize_t Ext2FS::read_inode_bytes(InodeIdentifier inode, Unix::off_t offset, Unix::size_t count, byte* buffer, FileDescriptor*) const
 {
     ASSERT(offset >= 0);
     ASSERT(inode.fsid() == id());
@@ -501,7 +501,7 @@ Unix::ssize_t Ext2FileSystem::read_inode_bytes(InodeIdentifier inode, Unix::off_
     return nread;
 }
 
-bool Ext2FileSystem::writeInode(InodeIdentifier inode, const ByteBuffer& data)
+bool Ext2FS::writeInode(InodeIdentifier inode, const ByteBuffer& data)
 {
     ASSERT(inode.fsid() == id());
 
@@ -536,7 +536,7 @@ bool Ext2FileSystem::writeInode(InodeIdentifier inode, const ByteBuffer& data)
     return true;
 }
 
-bool Ext2Inode::traverse_as_directory(Function<bool(const FileSystem::DirectoryEntry&)> callback)
+bool Ext2FSInode::traverse_as_directory(Function<bool(const FS::DirectoryEntry&)> callback)
 {
     ASSERT(metadata().isDirectory());
 
@@ -561,7 +561,7 @@ bool Ext2Inode::traverse_as_directory(Function<bool(const FileSystem::DirectoryE
     return true;
 }
 
-bool Ext2FileSystem::deprecated_enumerateDirectoryInode(InodeIdentifier inode, Function<bool(const DirectoryEntry&)> callback) const
+bool Ext2FS::deprecated_enumerateDirectoryInode(InodeIdentifier inode, Function<bool(const DirectoryEntry&)> callback) const
 {
     ASSERT(inode.fsid() == id());
     ASSERT(isDirectoryInode(inode.index()));
@@ -587,7 +587,7 @@ bool Ext2FileSystem::deprecated_enumerateDirectoryInode(InodeIdentifier inode, F
     return true;
 }
 
-bool Ext2FileSystem::addInodeToDirectory(unsigned directoryInode, unsigned inode, const String& name, byte fileType)
+bool Ext2FS::addInodeToDirectory(unsigned directoryInode, unsigned inode, const String& name, byte fileType)
 {
     auto e2inodeForDirectory = lookupExt2Inode(directoryInode);
     ASSERT(e2inodeForDirectory);
@@ -616,7 +616,7 @@ bool Ext2FileSystem::addInodeToDirectory(unsigned directoryInode, unsigned inode
     return writeDirectoryInode(directoryInode, move(entries));
 }
 
-bool Ext2FileSystem::writeDirectoryInode(unsigned directoryInode, Vector<DirectoryEntry>&& entries)
+bool Ext2FS::writeDirectoryInode(unsigned directoryInode, Vector<DirectoryEntry>&& entries)
 {
     kprintf("ext2fs: New directory inode %u contents to write:\n", directoryInode);
 
@@ -679,27 +679,27 @@ bool Ext2FileSystem::writeDirectoryInode(unsigned directoryInode, Vector<Directo
     return true;
 }
 
-unsigned Ext2FileSystem::inodesPerBlock() const
+unsigned Ext2FS::inodesPerBlock() const
 {
     return EXT2_INODES_PER_BLOCK(&superBlock());
 }
 
-unsigned Ext2FileSystem::inodesPerGroup() const
+unsigned Ext2FS::inodesPerGroup() const
 {
     return EXT2_INODES_PER_GROUP(&superBlock());
 }
 
-unsigned Ext2FileSystem::inodeSize() const
+unsigned Ext2FS::inodeSize() const
 {
     return EXT2_INODE_SIZE(&superBlock());
 
 }
-unsigned Ext2FileSystem::blocksPerGroup() const
+unsigned Ext2FS::blocksPerGroup() const
 {
     return EXT2_BLOCKS_PER_GROUP(&superBlock());
 }
 
-void Ext2FileSystem::dumpBlockBitmap(unsigned groupIndex) const
+void Ext2FS::dumpBlockBitmap(unsigned groupIndex) const
 {
     ASSERT(groupIndex <= m_blockGroupCount);
     auto& bgd = blockGroupDescriptor(groupIndex);
@@ -719,7 +719,7 @@ void Ext2FileSystem::dumpBlockBitmap(unsigned groupIndex) const
     kprintf("\n");
 }
 
-void Ext2FileSystem::dumpInodeBitmap(unsigned groupIndex) const
+void Ext2FS::dumpInodeBitmap(unsigned groupIndex) const
 {
     traverseInodeBitmap(groupIndex, [] (unsigned, const Bitmap& bitmap) {
         for (unsigned i = 0; i < bitmap.size(); ++i)
@@ -729,7 +729,7 @@ void Ext2FileSystem::dumpInodeBitmap(unsigned groupIndex) const
 }
 
 template<typename F>
-void Ext2FileSystem::traverseInodeBitmap(unsigned groupIndex, F callback) const
+void Ext2FS::traverseInodeBitmap(unsigned groupIndex, F callback) const
 {
     ASSERT(groupIndex <= m_blockGroupCount);
     auto& bgd = blockGroupDescriptor(groupIndex);
@@ -747,7 +747,7 @@ void Ext2FileSystem::traverseInodeBitmap(unsigned groupIndex, F callback) const
 }
 
 template<typename F>
-void Ext2FileSystem::traverseBlockBitmap(unsigned groupIndex, F callback) const
+void Ext2FS::traverseBlockBitmap(unsigned groupIndex, F callback) const
 {
     ASSERT(groupIndex <= m_blockGroupCount);
     auto& bgd = blockGroupDescriptor(groupIndex);
@@ -764,7 +764,7 @@ void Ext2FileSystem::traverseBlockBitmap(unsigned groupIndex, F callback) const
     }
 }
 
-bool Ext2FileSystem::modifyLinkCount(InodeIndex inode, int delta)
+bool Ext2FS::modifyLinkCount(InodeIndex inode, int delta)
 {
     ASSERT(inode);
     auto e2inode = lookupExt2Inode(inode);
@@ -778,7 +778,7 @@ bool Ext2FileSystem::modifyLinkCount(InodeIndex inode, int delta)
     return writeExt2Inode(inode, *e2inode);
 }
 
-bool Ext2FileSystem::set_mtime(InodeIdentifier inode, dword timestamp)
+bool Ext2FS::set_mtime(InodeIdentifier inode, dword timestamp)
 {
     ASSERT(inode.fsid() == id());
 
@@ -792,7 +792,7 @@ bool Ext2FileSystem::set_mtime(InodeIdentifier inode, dword timestamp)
     return writeExt2Inode(inode.index(), *e2inode);
 }
 
-bool Ext2FileSystem::writeExt2Inode(unsigned inode, const ext2_inode& e2inode)
+bool Ext2FS::writeExt2Inode(unsigned inode, const ext2_inode& e2inode)
 {
     unsigned blockIndex;
     unsigned offset;
@@ -804,14 +804,14 @@ bool Ext2FileSystem::writeExt2Inode(unsigned inode, const ext2_inode& e2inode)
     return true;
 }
 
-bool Ext2FileSystem::isDirectoryInode(unsigned inode) const
+bool Ext2FS::isDirectoryInode(unsigned inode) const
 {
     if (auto e2inode = lookupExt2Inode(inode))
         return isDirectory(e2inode->i_mode);
     return false;
 }
 
-Vector<Ext2FileSystem::BlockIndex> Ext2FileSystem::allocateBlocks(unsigned group, unsigned count)
+Vector<Ext2FS::BlockIndex> Ext2FS::allocateBlocks(unsigned group, unsigned count)
 {
     kprintf("ext2fs: allocateBlocks(group: %u, count: %u)\n", group, count);
 
@@ -841,7 +841,7 @@ Vector<Ext2FileSystem::BlockIndex> Ext2FileSystem::allocateBlocks(unsigned group
     return blocks;
 }
 
-unsigned Ext2FileSystem::allocateInode(unsigned preferredGroup, unsigned expectedSize)
+unsigned Ext2FS::allocateInode(unsigned preferredGroup, unsigned expectedSize)
 {
     kprintf("ext2fs: allocateInode(preferredGroup: %u, expectedSize: %u)\n", preferredGroup, expectedSize);
 
@@ -896,14 +896,14 @@ unsigned Ext2FileSystem::allocateInode(unsigned preferredGroup, unsigned expecte
     return inode;
 }
 
-unsigned Ext2FileSystem::groupIndexFromInode(unsigned inode) const
+unsigned Ext2FS::groupIndexFromInode(unsigned inode) const
 {
     if (!inode)
         return 0;
     return (inode - 1) / inodesPerGroup() + 1;
 }
 
-bool Ext2FileSystem::setInodeAllocationState(unsigned inode, bool newState)
+bool Ext2FS::setInodeAllocationState(unsigned inode, bool newState)
 {
     auto& bgd = blockGroupDescriptor(groupIndexFromInode(inode));
 
@@ -947,7 +947,7 @@ bool Ext2FileSystem::setInodeAllocationState(unsigned inode, bool newState)
     return true;
 }
 
-bool Ext2FileSystem::setBlockAllocationState(GroupIndex group, BlockIndex bi, bool newState)
+bool Ext2FS::setBlockAllocationState(GroupIndex group, BlockIndex bi, bool newState)
 {
     auto& bgd = blockGroupDescriptor(group);
 
@@ -991,7 +991,7 @@ bool Ext2FileSystem::setBlockAllocationState(GroupIndex group, BlockIndex bi, bo
     return true;
 }
 
-InodeIdentifier Ext2FileSystem::create_directory(InodeIdentifier parentInode, const String& name, Unix::mode_t mode)
+InodeIdentifier Ext2FS::create_directory(InodeIdentifier parentInode, const String& name, Unix::mode_t mode)
 {
     ASSERT(parentInode.fsid() == id());
     ASSERT(isDirectoryInode(parentInode.index()));
@@ -1030,7 +1030,7 @@ InodeIdentifier Ext2FileSystem::create_directory(InodeIdentifier parentInode, co
     return inode;
 }
 
-InodeIdentifier Ext2FileSystem::create_inode(InodeIdentifier parentInode, const String& name, Unix::mode_t mode, unsigned size)
+InodeIdentifier Ext2FS::create_inode(InodeIdentifier parentInode, const String& name, Unix::mode_t mode, unsigned size)
 {
     ASSERT(parentInode.fsid() == id());
     ASSERT(isDirectoryInode(parentInode.index()));
@@ -1119,7 +1119,7 @@ InodeIdentifier Ext2FileSystem::create_inode(InodeIdentifier parentInode, const
     return { id(), inode };
 }
 
-InodeIdentifier Ext2FileSystem::find_parent_of_inode(InodeIdentifier inode_id) const
+InodeIdentifier Ext2FS::find_parent_of_inode(InodeIdentifier inode_id) const
 {
     auto inode = get_inode(inode_id);
     ASSERT(inode);
@@ -1127,7 +1127,7 @@ InodeIdentifier Ext2FileSystem::find_parent_of_inode(InodeIdentifier inode_id) c
     unsigned groupIndex = groupIndexFromInode(inode->index());
     unsigned firstInodeInGroup = inodesPerGroup() * (groupIndex - 1);
 
-    Vector<RetainPtr<Ext2Inode>> directories_in_group;
+    Vector<RetainPtr<Ext2FSInode>> directories_in_group;
 
     for (unsigned i = 0; i < inodesPerGroup(); ++i) {
         auto group_member = get_inode({ id(), firstInodeInGroup + i });
@@ -1148,7 +1148,7 @@ InodeIdentifier Ext2FileSystem::find_parent_of_inode(InodeIdentifier inode_id) c
     return foundParent;
 }
 
-void Ext2Inode::populate_lookup_cache()
+void Ext2FSInode::populate_lookup_cache()
 {
     {
         LOCKER(m_lock);
@@ -1168,7 +1168,7 @@ void Ext2Inode::populate_lookup_cache()
     m_lookup_cache = move(children);
 }
 
-InodeIdentifier Ext2Inode::lookup(const String& name)
+InodeIdentifier Ext2FSInode::lookup(const String& name)
 {
     ASSERT(is_directory());
     populate_lookup_cache();
@@ -1179,7 +1179,7 @@ InodeIdentifier Ext2Inode::lookup(const String& name)
     return { };
 }
 
-String Ext2Inode::reverse_lookup(InodeIdentifier child_id)
+String Ext2FSInode::reverse_lookup(InodeIdentifier child_id)
 {
     ASSERT(is_directory());
     ASSERT(child_id.fsid() == fsid());
diff --git a/VirtualFileSystem/Ext2FileSystem.h b/VirtualFileSystem/Ext2FileSystem.h
index c5c0b3445b..c24974b33c 100644
--- a/VirtualFileSystem/Ext2FileSystem.h
+++ b/VirtualFileSystem/Ext2FileSystem.h
@@ -10,12 +10,12 @@ struct ext2_group_desc;
 struct ext2_inode;
 struct ext2_super_block;
 
-class Ext2FileSystem;
+class Ext2FS;
 
-class Ext2Inode final : public CoreInode {
-    friend class Ext2FileSystem;
+class Ext2FSInode final : public CoreInode {
+    friend class Ext2FS;
 public:
-    virtual ~Ext2Inode() override;
+    virtual ~Ext2FSInode() override;
 
     size_t size() const { return m_raw_inode.i_size; }
     bool is_symlink() const { return isSymbolicLink(m_raw_inode.i_mode); }
@@ -24,15 +24,15 @@ private:
     // ^CoreInode
     virtual Unix::ssize_t read_bytes(Unix::off_t, Unix::size_t, byte* buffer, FileDescriptor*) override;
     virtual void populate_metadata() const override;
-    virtual bool traverse_as_directory(Function<bool(const FileSystem::DirectoryEntry&)>) override;
+    virtual bool traverse_as_directory(Function<bool(const FS::DirectoryEntry&)>) override;
     virtual InodeIdentifier lookup(const String& name) override;
     virtual String reverse_lookup(InodeIdentifier) override;
 
     void populate_lookup_cache();
 
-    Ext2FileSystem& fs();
-    const Ext2FileSystem& fs() const;
-    Ext2Inode(Ext2FileSystem&, unsigned index, const ext2_inode&);
+    Ext2FS& fs();
+    const Ext2FS& fs() const;
+    Ext2FSInode(Ext2FS&, unsigned index, const ext2_inode&);
 
     SpinLock m_lock;
     Vector<unsigned> m_block_list;
@@ -40,11 +40,11 @@ private:
     ext2_inode m_raw_inode;
 };
 
-class Ext2FileSystem final : public DiskBackedFileSystem {
-    friend class Ext2Inode;
+class Ext2FS final : public DiskBackedFS {
+    friend class Ext2FSInode;
 public:
-    static RetainPtr<Ext2FileSystem> create(RetainPtr<DiskDevice>&&);
-    virtual ~Ext2FileSystem() override;
+    static RetainPtr<Ext2FS> create(RetainPtr<DiskDevice>&&);
+    virtual ~Ext2FS() override;
     virtual bool initialize() override;
 
 private:
@@ -54,7 +54,7 @@ private:
     class CachedExt2Inode;
     class CachedExt2InodeImpl;
 
-    explicit Ext2FileSystem(RetainPtr<DiskDevice>&&);
+    explicit Ext2FS(RetainPtr<DiskDevice>&&);
 
     const ext2_super_block& superBlock() const;
     const ext2_group_desc& blockGroupDescriptor(unsigned groupIndex) const;
@@ -113,15 +113,15 @@ private:
     mutable HashMap<unsigned, RetainPtr<CachedExt2InodeImpl>> m_inodeCache;
 
     mutable SpinLock m_inode_cache_lock;
-    mutable HashMap<BlockIndex, RetainPtr<Ext2Inode>> m_inode_cache;
+    mutable HashMap<BlockIndex, RetainPtr<Ext2FSInode>> m_inode_cache;
 };
 
-inline Ext2FileSystem& Ext2Inode::fs()
+inline Ext2FS& Ext2FSInode::fs()
 {
-    return static_cast<Ext2FileSystem&>(CoreInode::fs());
+    return static_cast<Ext2FS&>(CoreInode::fs());
 }
 
-inline const Ext2FileSystem& Ext2Inode::fs() const
+inline const Ext2FS& Ext2FSInode::fs() const
 {
-    return static_cast<const Ext2FileSystem&>(CoreInode::fs());
+    return static_cast<const Ext2FS&>(CoreInode::fs());
 }
diff --git a/VirtualFileSystem/FileSystem.cpp b/VirtualFileSystem/FileSystem.cpp
index 8cc9e0b281..7941e0b2a7 100644
--- a/VirtualFileSystem/FileSystem.cpp
+++ b/VirtualFileSystem/FileSystem.cpp
@@ -3,33 +3,33 @@
 #include "FileSystem.h"
 
 static dword s_lastFileSystemID;
-static HashMap<dword, FileSystem*>* map;
+static HashMap<dword, FS*>* map;
 
-static HashMap<dword, FileSystem*>& fileSystems()
+static HashMap<dword, FS*>& fileSystems()
 {
     if (!map)
-        map = new HashMap<dword, FileSystem*>();
+        map = new HashMap<dword, FS*>();
     return *map;
 }
 
-void FileSystem::initializeGlobals()
+void FS::initializeGlobals()
 {
     s_lastFileSystemID = 0;
     map = 0;
 }
 
-FileSystem::FileSystem()
+FS::FS()
     : m_id(++s_lastFileSystemID)
 {
     fileSystems().set(m_id, this);
 }
 
-FileSystem::~FileSystem()
+FS::~FS()
 {
     fileSystems().remove(m_id);
 }
 
-FileSystem* FileSystem::fromID(dword id)
+FS* FS::fromID(dword id)
 {
     auto it = fileSystems().find(id);
     if (it != fileSystems().end())
@@ -69,7 +69,7 @@ ByteBuffer CoreInode::read_entire(FileDescriptor* descriptor)
     */
 }
 
-ByteBuffer FileSystem::readEntireInode(InodeIdentifier inode, FileDescriptor* handle) const
+ByteBuffer FS::readEntireInode(InodeIdentifier inode, FileDescriptor* handle) const
 {
     ASSERT(inode.fsid() == id());
 
@@ -106,7 +106,7 @@ ByteBuffer FileSystem::readEntireInode(InodeIdentifier inode, FileDescriptor* ha
     return contents;
 }
 
-FileSystem::DirectoryEntry::DirectoryEntry(const char* n, InodeIdentifier i, byte ft)
+FS::DirectoryEntry::DirectoryEntry(const char* n, InodeIdentifier i, byte ft)
     : name_length(strlen(name))
     , inode(i)
     , fileType(ft)
@@ -115,7 +115,7 @@ FileSystem::DirectoryEntry::DirectoryEntry(const char* n, InodeIdentifier i, byt
     name[name_length] = '\0';
 }
 
-FileSystem::DirectoryEntry::DirectoryEntry(const char* n, Unix::size_t nl, InodeIdentifier i, byte ft)
+FS::DirectoryEntry::DirectoryEntry(const char* n, Unix::size_t nl, InodeIdentifier i, byte ft)
     : name_length(nl)
     , inode(i)
     , fileType(ft)
diff --git a/VirtualFileSystem/FileSystem.h b/VirtualFileSystem/FileSystem.h
index 7f2ec9939e..eedcb0f9ed 100644
--- a/VirtualFileSystem/FileSystem.h
+++ b/VirtualFileSystem/FileSystem.h
@@ -19,13 +19,13 @@ static const dword mepoch = 476763780;
 class CoreInode;
 class FileDescriptor;
 
-class FileSystem : public Retainable<FileSystem> {
+class FS : public Retainable<FS> {
 public:
     static void initializeGlobals();
-    virtual ~FileSystem();
+    virtual ~FS();
 
     dword id() const { return m_id; }
-    static FileSystem* fromID(dword);
+    static FS* fromID(dword);
 
     virtual bool initialize() = 0;
     virtual const char* class_name() const = 0;
@@ -55,7 +55,7 @@ public:
     ByteBuffer readEntireInode(InodeIdentifier, FileDescriptor* = nullptr) const;
 
 protected:
-    FileSystem();
+    FS();
 
 private:
     dword m_id { 0 };
@@ -66,8 +66,8 @@ class CoreInode : public Retainable<CoreInode> {
 public:
     virtual ~CoreInode();
 
-    FileSystem& fs() { return m_fs; }
-    const FileSystem& fs() const { return m_fs; }
+    FS& fs() { return m_fs; }
+    const FS& fs() const { return m_fs; }
     unsigned fsid() const;
     unsigned index() const { return m_index; }
 
@@ -81,12 +81,12 @@ public:
     ByteBuffer read_entire(FileDescriptor* = nullptr);
 
     virtual Unix::ssize_t read_bytes(Unix::off_t, Unix::size_t, byte* buffer, FileDescriptor*) = 0;
-    virtual bool traverse_as_directory(Function<bool(const FileSystem::DirectoryEntry&)>) = 0;
+    virtual bool traverse_as_directory(Function<bool(const FS::DirectoryEntry&)>) = 0;
     virtual InodeIdentifier lookup(const String& name) = 0;
     virtual String reverse_lookup(InodeIdentifier) = 0;
 
 protected:
-    CoreInode(FileSystem& fs, unsigned index)
+    CoreInode(FS& fs, unsigned index)
         : m_fs(fs)
         , m_index(index)
     {
@@ -96,18 +96,18 @@ protected:
 
     mutable InodeMetadata m_metadata;
 private:
-    FileSystem& m_fs;
+    FS& m_fs;
     unsigned m_index { 0 };
 };
 
-inline FileSystem* InodeIdentifier::fileSystem()
+inline FS* InodeIdentifier::fileSystem()
 {
-    return FileSystem::fromID(m_fileSystemID);
+    return FS::fromID(m_fileSystemID);
 }
 
-inline const FileSystem* InodeIdentifier::fileSystem() const
+inline const FS* InodeIdentifier::fileSystem() const
 {
-    return FileSystem::fromID(m_fileSystemID);
+    return FS::fromID(m_fileSystemID);
 }
 
 inline InodeMetadata InodeIdentifier::metadata() const
diff --git a/VirtualFileSystem/InodeIdentifier.h b/VirtualFileSystem/InodeIdentifier.h
index afb2e4862e..5c2900b4ed 100644
--- a/VirtualFileSystem/InodeIdentifier.h
+++ b/VirtualFileSystem/InodeIdentifier.h
@@ -3,7 +3,7 @@
 #include <AK/ByteBuffer.h>
 #include <AK/Types.h>
 
-class FileSystem;
+class FS;
 struct InodeMetadata;
 
 class InodeIdentifier {
@@ -20,8 +20,8 @@ public:
     dword fsid() const { return m_fileSystemID; }
     dword index() const { return m_index; }
 
-    FileSystem* fileSystem();
-    const FileSystem* fileSystem() const;
+    FS* fileSystem();
+    const FS* fileSystem() const;
 
     bool operator==(const InodeIdentifier& other) const
     {
diff --git a/VirtualFileSystem/SyntheticFileSystem.cpp b/VirtualFileSystem/SyntheticFileSystem.cpp
index 220712a2b7..97ba97386b 100644
--- a/VirtualFileSystem/SyntheticFileSystem.cpp
+++ b/VirtualFileSystem/SyntheticFileSystem.cpp
@@ -9,20 +9,20 @@ typedef int InterruptDisabler;
 
 //#define SYNTHFS_DEBUG
 
-RetainPtr<SyntheticFileSystem> SyntheticFileSystem::create()
+RetainPtr<SynthFS> SynthFS::create()
 {
-    return adopt(*new SyntheticFileSystem);
+    return adopt(*new SynthFS);
 }
 
-SyntheticFileSystem::SyntheticFileSystem()
+SynthFS::SynthFS()
 {
 }
 
-SyntheticFileSystem::~SyntheticFileSystem()
+SynthFS::~SynthFS()
 {
 }
 
-bool SyntheticFileSystem::initialize()
+bool SynthFS::initialize()
 {
     // Add a File for the root directory.
     // FIXME: This needs work.
@@ -43,7 +43,7 @@ bool SyntheticFileSystem::initialize()
     return true;
 }
 
-RetainPtr<SynthFSInode> SyntheticFileSystem::create_directory(String&& name)
+RetainPtr<SynthFSInode> SynthFS::create_directory(String&& name)
 {
     auto file = adopt(*new SynthFSInode(*this, generateInodeIndex()));
     file->m_name = move(name);
@@ -55,7 +55,7 @@ RetainPtr<SynthFSInode> SyntheticFileSystem::create_directory(String&& name)
     return file;
 }
 
-RetainPtr<SynthFSInode> SyntheticFileSystem::create_text_file(String&& name, ByteBuffer&& contents, Unix::mode_t mode)
+RetainPtr<SynthFSInode> SynthFS::create_text_file(String&& name, ByteBuffer&& contents, Unix::mode_t mode)
 {
     auto file = adopt(*new SynthFSInode(*this, generateInodeIndex()));
     file->m_data = contents;
@@ -68,7 +68,7 @@ RetainPtr<SynthFSInode> SyntheticFileSystem::create_text_file(String&& name, Byt
     return file;
 }
 
-RetainPtr<SynthFSInode> SyntheticFileSystem::create_generated_file(String&& name, Function<ByteBuffer()>&& generator, Unix::mode_t mode)
+RetainPtr<SynthFSInode> SynthFS::create_generated_file(String&& name, Function<ByteBuffer()>&& generator, Unix::mode_t mode)
 {
     auto file = adopt(*new SynthFSInode(*this, generateInodeIndex()));
     file->m_generator = move(generator);
@@ -81,7 +81,7 @@ RetainPtr<SynthFSInode> SyntheticFileSystem::create_generated_file(String&& name
     return file;
 }
 
-InodeIdentifier SyntheticFileSystem::addFile(RetainPtr<SynthFSInode>&& file, InodeIndex parent)
+InodeIdentifier SynthFS::addFile(RetainPtr<SynthFSInode>&& file, InodeIndex parent)
 {
     ASSERT_INTERRUPTS_DISABLED();
     ASSERT(file);
@@ -95,7 +95,7 @@ InodeIdentifier SyntheticFileSystem::addFile(RetainPtr<SynthFSInode>&& file, Ino
     return new_inode_id;
 }
 
-bool SyntheticFileSystem::removeFile(InodeIndex inode)
+bool SynthFS::removeFile(InodeIndex inode)
 {
     ASSERT_INTERRUPTS_DISABLED();
     auto it = m_inodes.find(inode);
@@ -121,17 +121,17 @@ bool SyntheticFileSystem::removeFile(InodeIndex inode)
     return true;
 }
 
-const char* SyntheticFileSystem::class_name() const
+const char* SynthFS::class_name() const
 {
     return "synthfs";
 }
 
-InodeIdentifier SyntheticFileSystem::rootInode() const
+InodeIdentifier SynthFS::rootInode() const
 {
     return { id(), 1 };
 }
 
-InodeMetadata SyntheticFileSystem::inodeMetadata(InodeIdentifier inode) const
+InodeMetadata SynthFS::inodeMetadata(InodeIdentifier inode) const
 {
     InterruptDisabler disabler;
     ASSERT(inode.fsid() == id());
@@ -145,14 +145,14 @@ InodeMetadata SyntheticFileSystem::inodeMetadata(InodeIdentifier inode) const
     return (*it).value->m_metadata;
 }
 
-bool SyntheticFileSystem::set_mtime(InodeIdentifier, dword timestamp)
+bool SynthFS::set_mtime(InodeIdentifier, dword timestamp)
 {
     (void) timestamp;
     kprintf("FIXME: Implement SyntheticFileSystem::setModificationTime().\n");
     return false;
 }
 
-InodeIdentifier SyntheticFileSystem::create_inode(InodeIdentifier parentInode, const String& name, Unix::mode_t mode, unsigned size)
+InodeIdentifier SynthFS::create_inode(InodeIdentifier parentInode, const String& name, Unix::mode_t mode, unsigned size)
 {
     (void) parentInode;
     (void) name;
@@ -162,13 +162,13 @@ InodeIdentifier SyntheticFileSystem::create_inode(InodeIdentifier parentInode, c
     return { };
 }
 
-bool SyntheticFileSystem::writeInode(InodeIdentifier, const ByteBuffer&)
+bool SynthFS::writeInode(InodeIdentifier, const ByteBuffer&)
 {
     kprintf("FIXME: Implement SyntheticFileSystem::writeInode().\n");
     return false;
 }
 
-Unix::ssize_t SyntheticFileSystem::read_inode_bytes(InodeIdentifier inode, Unix::off_t offset, Unix::size_t count, byte* buffer, FileDescriptor* handle) const
+Unix::ssize_t SynthFS::read_inode_bytes(InodeIdentifier inode, Unix::off_t offset, Unix::size_t count, byte* buffer, FileDescriptor* handle) const
 {
     ASSERT(inode.fsid() == id());
 #ifdef SYNTHFS_DEBUG
@@ -205,7 +205,7 @@ Unix::ssize_t SyntheticFileSystem::read_inode_bytes(InodeIdentifier inode, Unix:
     return nread;
 }
 
-InodeIdentifier SyntheticFileSystem::create_directory(InodeIdentifier parentInode, const String& name, Unix::mode_t)
+InodeIdentifier SynthFS::create_directory(InodeIdentifier parentInode, const String& name, Unix::mode_t)
 {
     (void) parentInode;
     (void) name;
@@ -213,12 +213,12 @@ InodeIdentifier SyntheticFileSystem::create_directory(InodeIdentifier parentInod
     return { };
 }
 
-auto SyntheticFileSystem::generateInodeIndex() -> InodeIndex
+auto SynthFS::generateInodeIndex() -> InodeIndex
 {
     return m_nextInodeIndex++;
 }
 
-InodeIdentifier SyntheticFileSystem::find_parent_of_inode(InodeIdentifier inode) const
+InodeIdentifier SynthFS::find_parent_of_inode(InodeIdentifier inode) const
 {
     auto it = m_inodes.find(inode.index());
     if (it == m_inodes.end())
@@ -226,7 +226,7 @@ InodeIdentifier SyntheticFileSystem::find_parent_of_inode(InodeIdentifier inode)
     return (*it).value->m_parent;
 }
 
-RetainPtr<CoreInode> SyntheticFileSystem::get_inode(InodeIdentifier inode) const
+RetainPtr<CoreInode> SynthFS::get_inode(InodeIdentifier inode) const
 {
     auto it = m_inodes.find(inode.index());
     if (it == m_inodes.end())
@@ -234,7 +234,7 @@ RetainPtr<CoreInode> SyntheticFileSystem::get_inode(InodeIdentifier inode) const
     return (*it).value;
 }
 
-SynthFSInode::SynthFSInode(SyntheticFileSystem& fs, unsigned index)
+SynthFSInode::SynthFSInode(SynthFS& fs, unsigned index)
     : CoreInode(fs, index)
 {
     m_metadata.inode = { fs.id(), index };
@@ -276,7 +276,7 @@ Unix::ssize_t SynthFSInode::read_bytes(Unix::off_t offset, Unix::size_t count, b
     return nread;
 }
 
-bool SynthFSInode::traverse_as_directory(Function<bool(const FileSystem::DirectoryEntry&)> callback)
+bool SynthFSInode::traverse_as_directory(Function<bool(const FS::DirectoryEntry&)> callback)
 {
     InterruptDisabler disabler;
 #ifdef SYNTHFS_DEBUG
diff --git a/VirtualFileSystem/SyntheticFileSystem.h b/VirtualFileSystem/SyntheticFileSystem.h
index de14e53a47..8a675d1def 100644
--- a/VirtualFileSystem/SyntheticFileSystem.h
+++ b/VirtualFileSystem/SyntheticFileSystem.h
@@ -6,10 +6,10 @@
 
 class SynthFSInode;
 
-class SyntheticFileSystem : public FileSystem {
+class SynthFS : public FS {
 public:
-    virtual ~SyntheticFileSystem() override;
-    static RetainPtr<SyntheticFileSystem> create();
+    virtual ~SynthFS() override;
+    static RetainPtr<SynthFS> create();
 
     virtual bool initialize() override;
     virtual const char* class_name() const override;
@@ -29,7 +29,7 @@ protected:
     InodeIndex generateInodeIndex();
     static constexpr InodeIndex RootInodeIndex = 1;
 
-    SyntheticFileSystem();
+    SynthFS();
 
     RetainPtr<SynthFSInode> create_directory(String&& name);
     RetainPtr<SynthFSInode> create_text_file(String&& name, ByteBuffer&&, Unix::mode_t = 0010644);
@@ -44,7 +44,7 @@ private:
 };
 
 class SynthFSInode final : public CoreInode {
-    friend class SyntheticFileSystem;
+    friend class SynthFS;
 public:
     virtual ~SynthFSInode() override;
 
@@ -52,13 +52,13 @@ private:
     // ^CoreInode
     virtual Unix::ssize_t read_bytes(Unix::off_t, Unix::size_t, byte* buffer, FileDescriptor*) override;
     virtual void populate_metadata() const override;
-    virtual bool traverse_as_directory(Function<bool(const FileSystem::DirectoryEntry&)>) override;
+    virtual bool traverse_as_directory(Function<bool(const FS::DirectoryEntry&)>) override;
     virtual InodeIdentifier lookup(const String& name) override;
     virtual String reverse_lookup(InodeIdentifier) override;
 
-    SyntheticFileSystem& fs();
-    const SyntheticFileSystem& fs() const;
-    SynthFSInode(SyntheticFileSystem&, unsigned index);
+    SynthFS& fs();
+    const SynthFS& fs() const;
+    SynthFSInode(SynthFS&, unsigned index);
 
     String m_name;
     InodeIdentifier m_parent;
diff --git a/VirtualFileSystem/VirtualFileSystem.cpp b/VirtualFileSystem/VirtualFileSystem.cpp
index e351d653b6..d1e6e5ad80 100644
--- a/VirtualFileSystem/VirtualFileSystem.cpp
+++ b/VirtualFileSystem/VirtualFileSystem.cpp
@@ -25,7 +25,7 @@ VFS& VFS::the()
 void VFS::initialize_globals()
 {
     s_the = nullptr;
-    FileSystem::initializeGlobals();
+    FS::initializeGlobals();
 }
 
 VFS::VFS()
@@ -74,7 +74,7 @@ auto VFS::makeNode(InodeIdentifier inode) -> RetainPtr<Vnode>
     auto vnode = allocateNode();
     ASSERT(vnode);
 
-    FileSystem* fileSystem = inode.fileSystem();
+    FS* fileSystem = inode.fileSystem();
     fileSystem->retain();
 
     vnode->inode = inode;
@@ -129,7 +129,7 @@ auto VFS::get_or_create_node(CharacterDevice& device) -> RetainPtr<Vnode>
     return makeNode(device);
 }
 
-bool VFS::mount(RetainPtr<FileSystem>&& fileSystem, const String& path)
+bool VFS::mount(RetainPtr<FS>&& fileSystem, const String& path)
 {
     ASSERT(fileSystem);
     int error;
@@ -146,7 +146,7 @@ bool VFS::mount(RetainPtr<FileSystem>&& fileSystem, const String& path)
     return true;
 }
 
-bool VFS::mount_root(RetainPtr<FileSystem>&& fileSystem)
+bool VFS::mount_root(RetainPtr<FS>&& fileSystem)
 {
     if (m_root_vnode) {
         kprintf("VFS: mount_root can't mount another root\n");
@@ -243,9 +243,9 @@ bool VFS::is_vfs_root(InodeIdentifier inode) const
     return inode == m_root_vnode->inode;
 }
 
-void VFS::traverse_directory_inode(CoreInode& dir_inode, Function<bool(const FileSystem::DirectoryEntry&)> callback)
+void VFS::traverse_directory_inode(CoreInode& dir_inode, Function<bool(const FS::DirectoryEntry&)> callback)
 {
-    dir_inode.traverse_as_directory([&] (const FileSystem::DirectoryEntry& entry) {
+    dir_inode.traverse_as_directory([&] (const FS::DirectoryEntry& entry) {
         InodeIdentifier resolvedInode;
         if (auto mount = find_mount_for_host(entry.inode))
             resolvedInode = mount->guest();
@@ -257,7 +257,7 @@ void VFS::traverse_directory_inode(CoreInode& dir_inode, Function<bool(const Fil
             ASSERT(mount);
             resolvedInode = mount->host();
         }
-        callback(FileSystem::DirectoryEntry(entry.name, entry.name_length, resolvedInode, entry.fileType));
+        callback(FS::DirectoryEntry(entry.name, entry.name_length, resolvedInode, entry.fileType));
         return true;
     });
 }
@@ -597,7 +597,7 @@ const InodeMetadata& Vnode::metadata() const
     return m_cachedMetadata;
 }
 
-VFS::Mount::Mount(InodeIdentifier host, RetainPtr<FileSystem>&& guest_fs)
+VFS::Mount::Mount(InodeIdentifier host, RetainPtr<FS>&& guest_fs)
     : m_host(host)
     , m_guest(guest_fs->rootInode())
     , m_guest_fs(move(guest_fs))
diff --git a/VirtualFileSystem/VirtualFileSystem.h b/VirtualFileSystem/VirtualFileSystem.h
index 1895b665f6..a5c49b680e 100644
--- a/VirtualFileSystem/VirtualFileSystem.h
+++ b/VirtualFileSystem/VirtualFileSystem.h
@@ -49,8 +49,8 @@ public:
     void retain();
     void release();
 
-    FileSystem* fileSystem() { return inode.fileSystem(); }
-    const FileSystem* fileSystem() const { return inode.fileSystem(); }
+    FS* fileSystem() { return inode.fileSystem(); }
+    const FS* fileSystem() const { return inode.fileSystem(); }
 
     VFS* vfs() { return m_vfs; }
     const VFS* vfs() const { return m_vfs; }
@@ -80,17 +80,17 @@ public:
 
     class Mount {
     public:
-        Mount(InodeIdentifier host, RetainPtr<FileSystem>&&);
+        Mount(InodeIdentifier host, RetainPtr<FS>&&);
 
         InodeIdentifier host() const { return m_host; }
         InodeIdentifier guest() const { return m_guest; }
 
-        const FileSystem& guest_fs() const { return *m_guest_fs; }
+        const FS& guest_fs() const { return *m_guest_fs; }
 
     private:
         InodeIdentifier m_host;
         InodeIdentifier m_guest;
-        RetainPtr<FileSystem> m_guest_fs;
+        RetainPtr<FS> m_guest_fs;
     };
 
     static VFS& the() PURE;
@@ -110,8 +110,8 @@ public:
     Vnode* root() { return m_root_vnode.ptr(); }
     const Vnode* root() const { return m_root_vnode.ptr(); }
 
-    bool mount_root(RetainPtr<FileSystem>&&);
-    bool mount(RetainPtr<FileSystem>&&, const String& path);
+    bool mount_root(RetainPtr<FS>&&);
+    bool mount(RetainPtr<FS>&&, const String& path);
 
     RetainPtr<FileDescriptor> open(CharacterDevice&, int options);
     RetainPtr<FileDescriptor> open(const String& path, int& error, int options = 0, InodeIdentifier base = InodeIdentifier());
@@ -135,7 +135,7 @@ private:
 
     bool is_vfs_root(InodeIdentifier) const;
 
-    void traverse_directory_inode(CoreInode&, Function<bool(const FileSystem::DirectoryEntry&)>);
+    void traverse_directory_inode(CoreInode&, Function<bool(const FS::DirectoryEntry&)>);
     InodeIdentifier resolve_path(const String& path, int& error, CoreInode& base, int options = 0);
     InodeIdentifier resolve_path(const String& path, int& error, InodeIdentifier base = InodeIdentifier(), int options = 0);
     InodeIdentifier resolveSymbolicLink(InodeIdentifier base, InodeIdentifier symlinkInode, int& error);
diff --git a/VirtualFileSystem/test.cpp b/VirtualFileSystem/test.cpp
index aa863fc259..c90ebc87ec 100644
--- a/VirtualFileSystem/test.cpp
+++ b/VirtualFileSystem/test.cpp
@@ -14,7 +14,7 @@
 #include <AK/kmalloc.h>
 #include <AK/ktime.h>
 
-static RetainPtr<FileSystem> makeFileSystem(const char* imagePath);
+static RetainPtr<FS> makeFileSystem(const char* imagePath);
 
 int main(int c, char** v)
 {
@@ -72,8 +72,8 @@ int main(int c, char** v)
         return 0;
     }
 
-    auto synthfs = SyntheticFileSystem::create();
-    bool success = static_cast<FileSystem&>(*synthfs).initialize();
+    auto synthfs = SynthFS::create();
+    bool success = static_cast<FS&>(*synthfs).initialize();
     printf("synth->initialize(): returned %u\n", success);
 
     vfs.mount(std::move(synthfs), "/syn");
@@ -234,16 +234,16 @@ int main(int c, char** v)
     return 0;
 }
 
-RetainPtr<FileSystem> makeFileSystem(const char* imagePath)
+RetainPtr<FS> makeFileSystem(const char* imagePath)
 {
     auto fsImage = FileBackedDiskDevice::create(imagePath, 512);
     if (!fsImage->isValid()) {
         fprintf(stderr, "Failed to open fs image file '%s'\n", imagePath);
         exit(1);
     }
-    auto ext2 = Ext2FileSystem::create(std::move(fsImage));
+    auto ext2 = Ext2FS::create(std::move(fsImage));
 
-    bool success = static_cast<FileSystem&>(*ext2).initialize();
+    bool success = static_cast<FS&>(*ext2).initialize();
     printf("ext2->initialize(): returned %u\n", success);
     return ext2;
 }