https://bugs.gentoo.org/932793
https://github.com/supercollider/supercollider/pull/6331

Rebased by Ron Widler (https://bugs.gentoo.org/932793#c3).
--- a/common/SC_Codecvt.hpp
+++ b/common/SC_Codecvt.hpp
@@ -39,7 +39,7 @@
 #pragma once
 
 #include <string> // string
-#include <boost/filesystem/path.hpp> // path
+#include <filesystem>
 
 #ifdef _WIN32
 #    include <codecvt> // std::codecvt_utf8_utf16, utf16
@@ -74,9 +74,9 @@ inline std::string utf16_wcstr_to_utf8_string(const wchar_t* s) {
  *
  * On POSIX platforms, this just converts using .string(). On Windows, uses
  * conversion between UTF-16 and UTF-8. */
-inline std::string path_to_utf8_str(const boost::filesystem::path& p) {
+inline std::string path_to_utf8_str(const std::filesystem::path& p) {
 #ifdef _WIN32
-    return p.string(std::codecvt_utf8_utf16<wchar_t>());
+    return std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>>().to_bytes(p.native());
 #else
     return p.string();
 #endif // _WIN32
@@ -86,11 +86,13 @@ inline std::string path_to_utf8_str(const boost::filesystem::path& p) {
  *
  * On POSIX platforms, this converts using the default constructor. On Windows,
  * uses conversion between UTF-16 and UTF-8. */
-inline boost::filesystem::path utf8_str_to_path(const std::string& s) {
+inline std::filesystem::path utf8_str_to_path(const std::string& s) {
 #ifdef _WIN32
-    return boost::filesystem::path(s, std::codecvt_utf8_utf16<wchar_t>());
+    std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
+    std::wstring wideString = converter.from_bytes(s);
+    return std::filesystem::path(std::move(wideString));
 #else
-    return boost::filesystem::path(s);
+    return std::filesystem::path(s);
 #endif // _WIN32
 }
 
--- a/common/SC_Filesystem.hpp
+++ b/common/SC_Filesystem.hpp
@@ -76,7 +76,7 @@
 #include <map> // map
 #include <algorithm> // std::transform
 #include <string> // std::string
-#include <boost/filesystem/path.hpp> // path
+#include <filesystem> // std::filesystem
 
 #include "SC_Codecvt.hpp" // path_to_utf8_str
 
@@ -101,7 +101,7 @@ public:
     enum class DirName;
     struct Glob;
 
-    typedef boost::filesystem::path Path; ///< Path type.
+    typedef std::filesystem::path Path; ///< Path type.
     typedef std::map<DirName, Path> DirMap; ///< Type of directory name-to-path map.
 
     /// SuperCollider common directory names.
--- a/common/SC_Filesystem_macos.cpp
+++ b/common/SC_Filesystem_macos.cpp
@@ -29,9 +29,7 @@
 
 #    include "SC_Filesystem.hpp"
 
-// boost
-#    include <boost/filesystem/path.hpp> // path, parent_path()
-#    include <boost/filesystem/operations.hpp> // canonical, current_path()
+#    include <filesystem> // path, parent_path(), canonical, current_path()
 
 // system includes
 #    include <Foundation/NSAutoreleasePool.h>
@@ -98,7 +96,7 @@ Path SC_Filesystem::resolveIfAlias(const Path& p, bool& isAlias) {
 
         // #4252 - URLByResolvingAliasFileAtURL will remove last trailing slash ('/Users/' ->
         // '/Users', '/Users///' -> '/Users//'). Protect against this case.
-        auto* pEnd = p.c_str() + p.size();
+        auto* pEnd = p.c_str() + p.string().size();
         const auto* mismatchPos = std::mismatch(p.c_str(), pEnd, resolvedNsPath).first;
         // note that p.size() >= 1 because empty string would fail 'fileExistsAtPath'
         if (mismatchPos == pEnd || (mismatchPos == pEnd - 1 && *mismatchPos == '/')) {
@@ -211,14 +209,14 @@ Path SC_Filesystem::defaultResourceDirectory() {
         uint32_t bufsize = PATH_MAX;
         char relDir[PATH_MAX];
         if (_NSGetExecutablePath(relDir, &bufsize) == 0) {
-            ret = boost::filesystem::canonical(relDir); // resolve symlink
+            ret = std::filesystem::canonical(relDir); // resolve symlink
             ret = ret.parent_path();
         } else {
             // in case it failed, fall back to current directory
-            ret = boost::filesystem::current_path();
+            ret = std::filesystem::current_path();
         }
     }
-    ret = boost::filesystem::canonical(ret); // resolve lingering symlink
+    ret = std::filesystem::canonical(ret); // resolve lingering symlink
     return ret;
 }
 
--- a/common/SC_Filesystem_win.cpp
+++ b/common/SC_Filesystem_win.cpp
@@ -30,8 +30,7 @@
 #    include "SC_Filesystem.hpp"
 #    include "SC_Codecvt.hpp"
 
-// boost
-#    include <boost/filesystem/operations.hpp> // is_directory
+#    include <filesystem>
 
 // system
 #    include <Shlobj.h> // SHGetKnownFolderPath
@@ -63,12 +62,12 @@ SC_Filesystem::Glob* SC_Filesystem::makeGlob(const char* pattern) {
     Glob* glob = new Glob;
 
     // use make_preferred() to change / -> \ on Windows
-    boost::filesystem::path path = SC_Codecvt::utf8_str_to_path(pattern).make_preferred();
+    std::filesystem::path path = SC_Codecvt::utf8_str_to_path(pattern).make_preferred();
 
     // remove a trailing backslash. Even if searching with 'foo/.', this will
     // change to 'foo' harmlessly. Use has_parent_path() because otherwise '.'
     // (referring to the CWD) won't be recognized as a valid query.
-    if (path.filename_is_dot() && path.has_parent_path())
+    if (path.filename() == "." && path.has_parent_path())
         path = path.parent_path();
 
     // expand to home directory, if path starts with tilde
@@ -104,14 +103,14 @@ Path SC_Filesystem::globNext(Glob* glob) {
 
         if (!::FindNextFileW(glob->mHandle, &glob->mEntry))
             glob->mAtEnd = true;
-    } while (glob->mFilename.filename_is_dot() || glob->mFilename.filename_is_dot_dot());
+    } while (glob->mFilename.filename() == "." || glob->mFilename.filename() == "..");
 
     // add preferred separator (L'\\') for directories on Windows, to match
     // POSIX globbing. boost::filesystem::is_directory won't work for this because
     // in the case of input '.' and '..', the filename here is just a single folder,
     // not a relative path, and so can't be correctly identified. Plus, it's faster
     // to check the attributes than to make another system call.
-    return isDirectory ? glob->mFilename += boost::filesystem::path::preferred_separator : glob->mFilename;
+    return isDirectory ? glob->mFilename += std::filesystem::path::preferred_separator : glob->mFilename;
 }
 
 //============= PRIVATE METHODS ==============//
--- a/editors/sc-ide/core/util/standard_dirs.cpp
+++ b/editors/sc-ide/core/util/standard_dirs.cpp
@@ -22,7 +22,7 @@
 
 #include "SC_Filesystem.hpp" // getDirectory
 #include "SC_Codecvt.hpp" // path_to_utf8_str
-#include <boost/filesystem/path.hpp> // path
+#include <filesystem>
 
 namespace ScIDE {
 
@@ -59,7 +59,7 @@ QString standardDirectory(StandardDirectory type) {
         return QString();
     }
 
-    const boost::filesystem::path path = SC_Filesystem::instance().getDirectory(dn);
+    const std::filesystem::path path = SC_Filesystem::instance().getDirectory(dn);
     return QString(SC_Codecvt::path_to_utf8_str(path).c_str());
 }
 
--- a/lang/LangPrimSource/PyrFilePrim.cpp
+++ b/lang/LangPrimSource/PyrFilePrim.cpp
@@ -49,9 +49,7 @@ Primitives for File i/o.
 
 /* C++ stdlib headers */
 #include <tuple>
-
-/* boost headers */
-#include <boost/filesystem.hpp>
+#include <filesystem>
 
 /* system headers */
 #ifndef _WIN32
@@ -70,7 +68,7 @@ Primitives for File i/o.
 
 #define DELIMITOR ':'
 
-namespace bfs = boost::filesystem;
+namespace fs = std::filesystem;
 
 int prFileDelete(struct VMGlobals* g, int numArgsPushed) {
     PyrSlot *a = g->sp - 1, *b = g->sp;
@@ -80,9 +78,9 @@ int prFileDelete(struct VMGlobals* g, int numArgsPushed) {
     if (error != errNone)
         return error;
 
-    const bfs::path& p = SC_Codecvt::utf8_str_to_path(filename);
-    boost::system::error_code error_code;
-    bfs::remove(p, error_code);
+    const fs::path& p = SC_Codecvt::utf8_str_to_path(filename);
+    std::error_code error_code;
+    fs::remove(p, error_code);
 
     if (error_code)
         SetFalse(a);
@@ -100,8 +98,8 @@ int prFileDeleteAll(struct VMGlobals* g, int numArgsPushed) {
     if (error != errNone)
         return error;
 
-    const bfs::path& p = SC_Codecvt::utf8_str_to_path(filename);
-    if (bfs::remove_all(p) > 0) {
+    const fs::path& p = SC_Codecvt::utf8_str_to_path(filename);
+    if (fs::remove_all(p) > 0) {
         SetTrue(a);
     } else {
         SetFalse(a);
@@ -110,6 +108,13 @@ int prFileDeleteAll(struct VMGlobals* g, int numArgsPushed) {
     return errNone;
 }
 
+std::time_t to_time_t(std::filesystem::file_time_type file_time) {
+    using namespace std::chrono;
+    auto sctp = time_point_cast<system_clock::duration>(file_time - std::filesystem::file_time_type::clock::now()
+                                                        + system_clock::now());
+    return system_clock::to_time_t(sctp);
+}
+
 int prFileMTime(struct VMGlobals* g, int numArgsPushed) {
     PyrSlot *a = g->sp - 1, *b = g->sp;
     char filename[PATH_MAX];
@@ -118,9 +123,9 @@ int prFileMTime(struct VMGlobals* g, int numArgsPushed) {
     if (error != errNone)
         return error;
 
-    const bfs::path& p = SC_Codecvt::utf8_str_to_path(filename);
-    time_t mtime = bfs::last_write_time(p);
-    SetInt(a, mtime);
+    const fs::path& p = SC_Codecvt::utf8_str_to_path(filename);
+    auto mtime = fs::last_write_time(p);
+    SetInt(a, to_time_t(mtime));
     return errNone;
 }
 
@@ -132,8 +137,8 @@ int prFileExists(struct VMGlobals* g, int numArgsPushed) {
     if (error != errNone)
         return error;
 
-    const bfs::path& p = SC_Codecvt::utf8_str_to_path(filename);
-    bool res = bfs::exists(p);
+    const fs::path& p = SC_Codecvt::utf8_str_to_path(filename);
+    bool res = fs::exists(p);
     SetBool(a, res);
     return errNone;
 }
@@ -149,13 +154,13 @@ int prFileRealPath(struct VMGlobals* g, int numArgsPushed) {
         return err;
 
     bool isAlias = false;
-    bfs::path p = SC_Codecvt::utf8_str_to_path(ipath);
+    fs::path p = SC_Codecvt::utf8_str_to_path(ipath);
     p = SC_Filesystem::resolveIfAlias(p, isAlias);
     if (p.empty())
         return errFailed;
 
-    boost::system::error_code error_code;
-    p = bfs::canonical(p, error_code).make_preferred();
+    std::error_code error_code;
+    p = fs::canonical(p, error_code).make_preferred();
     if (error_code) {
         SetNil(a);
         return errNone;
@@ -178,8 +183,8 @@ int prFileMkDir(struct VMGlobals* g, int numArgsPushed) {
     if (error != errNone)
         return error;
 
-    const bfs::path& p = SC_Codecvt::utf8_str_to_path(filename);
-    bool result = bfs::create_directories(p);
+    const fs::path& p = SC_Codecvt::utf8_str_to_path(filename);
+    bool result = fs::create_directories(p);
 
     SetBool(a, result);
     return errNone;
@@ -197,10 +202,10 @@ int prFileCopy(struct VMGlobals* g, int numArgsPushed) {
     if (error != errNone)
         return error;
 
-    const bfs::path& p1 = SC_Codecvt::utf8_str_to_path(filename1);
-    const bfs::path& p2 = SC_Codecvt::utf8_str_to_path(filename2);
-    boost::system::error_code error_code;
-    bfs::copy(p1, p2, error_code);
+    const fs::path& p1 = SC_Codecvt::utf8_str_to_path(filename1);
+    const fs::path& p2 = SC_Codecvt::utf8_str_to_path(filename2);
+    std::error_code error_code;
+    fs::copy(p1, p2, error_code);
     if (error_code) {
         std::ostringstream s;
         s << error_code.message() << ": copy from \"" << filename1 << "\" to \"" << filename2 << "\"";
@@ -210,6 +215,34 @@ int prFileCopy(struct VMGlobals* g, int numArgsPushed) {
     return errNone;
 }
 
+int prFileTypeToInt(const fs::file_type& type) {
+    // see https://en.cppreference.com/w/cpp/filesystem/file_type
+    // and also check this with the `File.type` method located in
+    // `Common/Files/Files.sc`
+    switch (type) {
+    case fs::file_type::none:
+        return 0;
+    case fs::file_type::not_found:
+        return 1;
+    case fs::file_type::regular:
+        return 2;
+    case fs::file_type::directory:
+        return 3;
+    case fs::file_type::symlink:
+        return 4;
+    case fs::file_type::block:
+        return 5;
+    case fs::file_type::character:
+        return 6;
+    case fs::file_type::fifo:
+        return 7;
+    case fs::file_type::socket:
+        return 8;
+    default:
+        return 0;
+    }
+}
+
 int prFileType(struct VMGlobals* g, int numArgsPushed) {
     PyrSlot *a = g->sp - 1, *b = g->sp;
     char filename[PATH_MAX];
@@ -218,9 +251,9 @@ int prFileType(struct VMGlobals* g, int numArgsPushed) {
     if (error != errNone)
         return error;
 
-    const bfs::path& p = SC_Codecvt::utf8_str_to_path(filename);
-    bfs::file_status s(bfs::symlink_status(p));
-    SetInt(a, s.type());
+    const fs::path& p = SC_Codecvt::utf8_str_to_path(filename);
+    fs::file_status s(fs::symlink_status(p));
+    SetInt(a, prFileTypeToInt(s.type()));
     return errNone;
 }
 
@@ -232,8 +265,8 @@ int prFileSize(struct VMGlobals* g, int numArgsPushed) {
     if (error != errNone)
         return error;
 
-    const bfs::path& p = SC_Codecvt::utf8_str_to_path(filename);
-    uintmax_t sz = bfs::file_size(p);
+    const fs::path& p = SC_Codecvt::utf8_str_to_path(filename);
+    uintmax_t sz = fs::file_size(p);
     SetInt(a, sz);
     return errNone;
 }
@@ -261,7 +294,7 @@ int prFileOpen(struct VMGlobals* g, int numArgsPushed) {
 
     memcpy(filename, slotRawString(b)->s, slotRawObject(b)->size);
     filename[slotRawString(b)->size] = 0;
-    const bfs::path& path = SC_Codecvt::utf8_str_to_path(filename);
+    const fs::path& path = SC_Codecvt::utf8_str_to_path(filename);
 
     memcpy(mode, slotRawString(c)->s, slotRawObject(c)->size);
     mode[slotRawString(c)->size] = 0;
@@ -288,7 +321,7 @@ int prFileOpen(struct VMGlobals* g, int numArgsPushed) {
         // check if directory exisits
         // create a temporary file (somewhere) for a handle
         // the file is deleted automatically when closed
-        if (bfs::is_directory(path)) {
+        if (fs::is_directory(path)) {
             int err;
 #    ifdef _MSC_VER
             err = tmpfile_s(&file);
--- a/lang/LangPrimSource/PyrPlatformPrim.cpp
+++ b/lang/LangPrimSource/PyrPlatformPrim.cpp
@@ -34,15 +34,15 @@ Primitives for platform dependent directories, constants etc.
 #    include "Shlobj.h"
 #endif
 
-#include <boost/filesystem/path.hpp> // path
+#include <filesystem>
 #include <boost/predef/architecture.h>
 
-namespace bfs = boost::filesystem;
+namespace fs = std::filesystem;
 using DirName = SC_Filesystem::DirName;
 
 static inline int prPlatform_getDirectory(const struct VMGlobals* g, const DirName dirname) {
     PyrSlot* a = g->sp;
-    const bfs::path& p = SC_Filesystem::instance().getDirectory(dirname);
+    const fs::path& p = SC_Filesystem::instance().getDirectory(dirname);
     PyrString* string = newPyrString(g->gc, SC_Codecvt::path_to_utf8_str(p).c_str(), 0, true);
     SetObject(a, string);
     return errNone;
--- a/lang/LangPrimSource/PyrPrimitive.cpp
+++ b/lang/LangPrimSource/PyrPrimitive.cpp
@@ -63,13 +63,13 @@
 
 #include "SCDocPrim.h"
 
-#include <boost/filesystem/path.hpp> // path
+#include <filesystem>
 
 #ifdef __clang__
 #    pragma clang diagnostic ignored "-Warray-bounds"
 #endif
 
-namespace bfs = boost::filesystem;
+namespace fs = std::filesystem;
 
 int yyparse();
 
@@ -3580,7 +3580,7 @@ static int prLanguageConfig_addLibraryPath(struct VMGlobals* g, int numArgsPushe
     if (error)
         return errWrongType;
 
-    const bfs::path& native_path = SC_Codecvt::utf8_str_to_path(path);
+    const fs::path& native_path = SC_Codecvt::utf8_str_to_path(path);
     if (pathType == includePaths)
         gLanguageConfig->addIncludedDirectory(native_path);
     else
@@ -3604,7 +3604,7 @@ static int prLanguageConfig_removeLibraryPath(struct VMGlobals* g, int numArgsPu
     if (error)
         return errWrongType;
 
-    const bfs::path& native_path = SC_Codecvt::utf8_str_to_path(path);
+    const fs::path& native_path = SC_Codecvt::utf8_str_to_path(path);
     if (pathType == includePaths)
         gLanguageConfig->removeIncludedDirectory(native_path);
     else
@@ -3635,7 +3635,7 @@ static int prLanguageConfig_getCurrentConfigPath(struct VMGlobals* g, int numArg
 
 static int prLanguageConfig_writeConfigFile(struct VMGlobals* g, int numArgsPushed) {
     PyrSlot* fileString = g->sp;
-    bfs::path config_path;
+    fs::path config_path;
 
     if (NotNil(fileString)) {
         char path[MAXPATHLEN];
--- a/lang/LangPrimSource/PyrStringPrim.cpp
+++ b/lang/LangPrimSource/PyrStringPrim.cpp
@@ -45,13 +45,14 @@ Primitives for String.
 #include <boost/regex.hpp>
 #include <boost/intrusive/list.hpp>
 #include <boost/intrusive/unordered_set.hpp>
-#include <boost/filesystem/fstream.hpp> // ifstream
-#include <boost/filesystem/path.hpp> // path
+
+#include <fstream>
+#include <filesystem>
 
 #include <yaml-cpp/yaml.h>
 
 using namespace std;
-namespace bfs = boost::filesystem;
+namespace fs = std::filesystem;
 
 int prStringAsSymbol(struct VMGlobals* g, int numArgsPushed) {
     PyrSlot* a;
@@ -531,9 +532,9 @@ int prString_PathMatch(struct VMGlobals* g, int numArgsPushed) {
     }
 
     // read all paths into a vector
-    std::vector<bfs::path> paths;
+    std::vector<fs::path> paths;
     while (true) {
-        const bfs::path& matched_path = SC_Filesystem::globNext(glob);
+        const fs::path& matched_path = SC_Filesystem::globNext(glob);
         if (matched_path.empty())
             break;
         else
@@ -827,7 +828,7 @@ int prString_StandardizePath(struct VMGlobals* g, int /* numArgsPushed */) {
     if (err != errNone)
         return err;
 
-    bfs::path p = SC_Codecvt::utf8_str_to_path(ipath);
+    fs::path p = SC_Codecvt::utf8_str_to_path(ipath);
     p = SC_Filesystem::instance().expandTilde(p);
     bool isAlias;
     p = SC_Filesystem::resolveIfAlias(p, isAlias);
@@ -968,8 +969,8 @@ int prString_ParseYAMLFile(struct VMGlobals* g, int numArgsPushed) {
 
     string str((const char*)slotRawString(arg)->s, slotRawString(arg)->size);
 
-    const bfs::path& path = SC_Codecvt::utf8_str_to_path(str);
-    bfs::ifstream fin(path);
+    const fs::path& path = SC_Codecvt::utf8_str_to_path(str);
+    std::ifstream fin(path);
     YAML::Node doc = YAML::Load(fin);
     yaml_traverse(g, doc, nullptr, arg);
 
--- a/lang/LangPrimSource/PyrUnixPrim.cpp
+++ b/lang/LangPrimSource/PyrUnixPrim.cpp
@@ -26,6 +26,7 @@
 #include <cstring>
 #include <errno.h>
 #include <signal.h>
+#include <boost/date_time/posix_time/posix_time_io.hpp>

 #include <tuple>
 #include <vector>
@@ -46,7 +46,7 @@ Primitives for Unix.
 
 #include "SC_Lock.h"
 
-#include <boost/filesystem.hpp>
+#include <filesystem>
 
 #ifdef _WIN32
 #    include "SC_Win32Utils.h"
@@ -54,7 +54,7 @@ Primitives for Unix.
 #    include <libgen.h>
 #endif
 
-namespace bfs = boost::filesystem;
+namespace fs = std::filesystem;
 
 extern bool compiledOK;
 PyrSymbol* s_unixCmdAction;
--- a/lang/LangSource/PyrLexer.cpp
+++ b/lang/LangSource/PyrLexer.cpp
@@ -36,9 +36,8 @@
 #    include <sys/param.h>
 #endif
 
-#include <boost/filesystem/path.hpp>
-#include <boost/filesystem/operations.hpp>
-#include "boost_string_file.hpp"
+#include <filesystem>
+#include <fstream>
 
 #include "PyrParseNode.h"
 #include "Bison/lang11d_tab.h"
@@ -84,12 +83,12 @@ int gNumCompiledFiles;
 thisProcess.interpreter.executeFile("Macintosh HD:score").size.postln;
 */
 
-namespace bfs = boost::filesystem;
+namespace fs = std::filesystem;
 using DirName = SC_Filesystem::DirName;
 
 PyrSymbol* gCompilingFileSym = nullptr;
 VMGlobals* gCompilingVMGlobals = nullptr;
-static bfs::path gCompileDir;
+static fs::path gCompileDir;
 
 //#define DEBUGLEX 1
 bool gDebugLexer = false;
@@ -102,7 +101,7 @@ int lastClosedFuncCharNo = 0;
 
 const char* binopchars = "!@%&*-+=|<>?/";
 char yytext[MAXYYLEN];
-bfs::path currfilename;
+fs::path currfilename;
 std::string printingCurrfilename; // for error reporting
 
 int yylen;
@@ -122,7 +121,7 @@ int textpos;
 int errLineOffset, errCharPosOffset;
 int parseFailed = 0;
 bool compiledOK = false;
-std::set<bfs::path> compiledDirectories;
+std::set<fs::path> compiledDirectories;
 
 /* so the text editor's dumb paren matching will work */
 #define OPENPAREN '('
@@ -170,18 +169,18 @@ double sc_strtof(const char* str, int n, int base) {
     return z;
 }
 
-bool startLexer(PyrSymbol* fileSym, const bfs::path& p, int startPos, int endPos, int lineOffset);
-bool startLexer(PyrSymbol* fileSym, const bfs::path& p, int startPos, int endPos, int lineOffset) {
+bool startLexer(PyrSymbol* fileSym, const fs::path& p, int startPos, int endPos, int lineOffset);
+bool startLexer(PyrSymbol* fileSym, const fs::path& p, int startPos, int endPos, int lineOffset) {
     const char* filename = fileSym->name;
 
     textlen = -1;
 
     if (!fileSym->u.source) {
         try {
-            bfs::ifstream file;
+            std::ifstream file;
             file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
             file.open(p, std::ios_base::binary);
-            size_t sz = bfs::file_size(p);
+            size_t sz = fs::file_size(p);
 
             text = (char*)pyr_pool_compile->Alloc((sz + 1) * sizeof(char));
             MEMFAIL(text);
@@ -225,7 +224,7 @@ bool startLexer(PyrSymbol* fileSym, const bfs::path& p, int startPos, int endPos
     zzval = 0;
     parseFailed = 0;
     lexCmdLine = 0;
-    currfilename = bfs::path(filename);
+    currfilename = fs::path(filename);
     printingCurrfilename = "file '" + SC_Codecvt::path_to_utf8_str(currfilename) + "'";
     maxlinestarts = 1000;
     linestarts = (int*)pyr_pool_compile->Alloc(maxlinestarts * sizeof(int*));
@@ -261,7 +260,7 @@ void startLexerCmdLine(char* textbuf, int textbuflen) {
     zzval = 0;
     parseFailed = 0;
     lexCmdLine = 1;
-    currfilename = bfs::path("interpreted text");
+    currfilename = fs::path("interpreted text");
     printingCurrfilename = currfilename.string();
     maxlinestarts = 1000;
     linestarts = (int*)pyr_pool_compile->Alloc(maxlinestarts * sizeof(int*));
@@ -1721,7 +1720,7 @@ void compileClass(PyrSymbol* fileSym, int startPos, int endPos, int lineOffset)
     gCompilingVMGlobals = nullptr;
     gRootParseNode = nullptr;
     initParserPool();
-    if (startLexer(fileSym, bfs::path(), startPos, endPos, lineOffset)) {
+    if (startLexer(fileSym, fs::path(), startPos, endPos, lineOffset)) {
         // postfl("->Parsing %s\n", fileSym->name); fflush(stdout);
         parseFailed = yyparse();
         // postfl("<-Parsing %s %d\n", fileSym->name, parseFailed); fflush(stdout);
@@ -1733,7 +1732,7 @@ void compileClass(PyrSymbol* fileSym, int startPos, int endPos, int lineOffset)
             // postfl("done compiling\n");fflush(stdout);
         } else {
             compileErrors++;
-            bfs::path pathname(fileSym->name);
+            fs::path pathname(fileSym->name);
             error("file '%s' parse failed\n", SC_Codecvt::path_to_utf8_str(pathname).c_str());
             postfl("error parsing\n");
         }
@@ -1942,7 +1941,7 @@ void finiPassOne() {
 /**
  * \brief \c true if \c dir is one of the language config's default classlib directories
  */
-static bool isDefaultClassLibraryDirectory(const bfs::path& dir) {
+static bool isDefaultClassLibraryDirectory(const fs::path& dir) {
     auto const& defaultDirs = gLanguageConfig->defaultClassLibraryDirectories();
     auto const iter = std::find(defaultDirs.begin(), defaultDirs.end(), dir);
     return iter != defaultDirs.end();
@@ -1955,10 +1954,10 @@ static bool isDefaultClassLibraryDirectory(const bfs::path& dir) {
  * try to create it, silently ignoring failure (most likely from permissions failure).
  * Otherwise, warn the user to help catch mistyped/missing directory names. See #3468.
  */
-static void passOne_HandleMissingDirectory(const bfs::path& dir) {
+static void passOne_HandleMissingDirectory(const fs::path& dir) {
     if (isDefaultClassLibraryDirectory(dir)) {
-        boost::system::error_code ec {};
-        bfs::create_directories(dir, ec);
+        std::error_code ec {};
+        fs::create_directories(dir, ec);
     } else {
         post("WARNING: Could not open directory: '%s'\n"
              "\tTo resolve this, either create the directory or remove it from your compilation paths.\n\n",
@@ -1966,7 +1965,7 @@ static void passOne_HandleMissingDirectory(const bfs::path& dir) {
     }
 }
 
-bfs::path relativeToCompileDir(const bfs::path& p) { return bfs::relative(p, gCompileDir); }
+fs::path relativeToCompileDir(const fs::path& p) { return fs::relative(p, gCompileDir); }
 
 /** \brief Determines whether the directory should be skipped during compilation.
  *
@@ -1976,7 +1975,7 @@ bfs::path relativeToCompileDir(const bfs::path& p) { return bfs::relative(p, gCo
  * - the language configuration says this path is excluded
  * - SC_Filesystem::shouldNotCompileDirectory(dir) returns `true`
  */
-static bool passOne_ShouldSkipDirectory(const bfs::path& dir) {
+static bool passOne_ShouldSkipDirectory(const fs::path& dir) {
     return (compiledDirectories.find(dir) != compiledDirectories.end())
         || (gLanguageConfig && gLanguageConfig->pathIsExcluded(dir))
         || (SC_Filesystem::instance().shouldNotCompileDirectory(dir));
@@ -2003,24 +2002,24 @@ static bool passOne_ShouldSkipDirectory(const bfs::path& dir) {
  * \returns `true` if processing was successful, `false` if it failed.
  *   See above for what constitutes success and failure conditions.
  */
-static bool passOne_ProcessDir(const bfs::path& dir) {
+static bool passOne_ProcessDir(const fs::path& dir) {
     // Prefer non-throwing versions of filesystem functions, since they are actually not unexpected
     // and because it's faster to use error codes.
-    boost::system::error_code ec;
+    std::error_code ec;
 
     // Perform tilde expansion on incoming dir.
-    const bfs::path expdir = SC_Filesystem::instance().expandTilde(dir);
+    const fs::path expdir = SC_Filesystem::instance().expandTilde(dir);
 
     // Using a recursive_directory_iterator is much faster than actually calling this function
     // recursively. Speedup from the switch was about 1.5x. _Do_ recurse on symlinks.
-    bfs::recursive_directory_iterator rditer(expdir, bfs::symlink_option::recurse, ec);
+    fs::recursive_directory_iterator rditer(expdir, fs::directory_options::follow_directory_symlink, ec);
 
     // Check preconditions: are we able to access the file, and should we compile it according to
     // the language configuration?
     if (ec) {
         // If we got an error, post a warning if it was because the target wasn't found, and return success.
         // Otherwise, post the error and fail.
-        if (ec.default_error_condition().value() == boost::system::errc::no_such_file_or_directory) {
+        if (ec.default_error_condition() == std::errc::no_such_file_or_directory) {
             passOne_HandleMissingDirectory(expdir);
             return true;
         } else {
@@ -2042,14 +2041,14 @@ static bool passOne_ProcessDir(const bfs::path& dir) {
 
     // Invariant: we have processed (or begun to process) every directory or file already
     // touched by the iterator.
-    while (rditer != bfs::end(rditer)) {
-        const bfs::path path = *rditer;
+    while (rditer != fs::end(rditer)) {
+        const fs::path path = *rditer;
 
         // If the file is a directory, perform the same checks as above to see if we should
         // skip compilation on it.
-        if (bfs::is_directory(path)) {
+        if (fs::is_directory(path)) {
             if (passOne_ShouldSkipDirectory(path)) {
-                rditer.no_push(); // don't "push" into the next level of the hierarchy
+                rditer.disable_recursion_pending(); // don't "push" into the next level of the hierarchy
             } else {
                 // Mark this directory as compiled.
                 // By not calling no_push(), we allow the iterator to enter the directory
@@ -2062,8 +2061,8 @@ static bool passOne_ProcessDir(const bfs::path& dir) {
             // - resolution failed: returns empty path: let the user know
             // - it was not an alias, or was an alias that wasn't a directory: try to process it as a source file
             bool isAlias = false;
-            const bfs::path& respath = SC_Filesystem::resolveIfAlias(path, isAlias);
-            if (isAlias && bfs::is_directory(respath)) {
+            const fs::path& respath = SC_Filesystem::resolveIfAlias(path, isAlias);
+            if (isAlias && fs::is_directory(respath)) {
                 // If the resolved alias is a directory, recurse on it.
                 if (!passOne_ProcessDir(respath)) {
                     return false;
@@ -2095,8 +2094,8 @@ bool passOne() {
 }
 
 /// True if file doesn't begin with '.', and ends with either '.sc' or '.rtf'
-bool isValidSourceFileName(const bfs::path& path) {
-    const bfs::path& ext = path.extension();
+bool isValidSourceFileName(const fs::path& path) {
+    const fs::path& ext = path.extension();
     return path.filename().c_str()[0] != '.' && // must not be hidden file
         ((ext == ".sc") || (ext == ".rtf" && path.stem().extension() == ".sc"));
 }
@@ -2110,7 +2109,7 @@ bool isValidSourceFileName(const bfs::path& path) {
  * \returns Whether parsing was successful. The only failure condition occurs
  * when the file can't be opened.
  */
-bool passOne_ProcessOneFile(const bfs::path& path) {
+bool passOne_ProcessOneFile(const fs::path& path) {
     bool success = true;
 
     const std::string path_str = SC_Codecvt::path_to_utf8_str(path);
--- a/lang/LangSource/PyrLexer.h
+++ b/lang/LangSource/PyrLexer.h
@@ -25,7 +25,7 @@
 #include "PyrSymbol.h"
 #include "SC_Export.h"
 #include "SCBase.h"
-#include <boost/filesystem/path.hpp>
+#include <filesystem>
 
 extern int charno, lineno, linepos;
 extern int* linestarts;
@@ -78,10 +78,10 @@ void startLexerCmdLine(char* textbuf, int textbuflen);
 int yylex();
 void yyerror(const char* s);
 void fatal();
-bool isValidSourceFileName(const boost::filesystem::path& path);
-bool passOne_ProcessOneFile(const boost::filesystem::path& path);
+bool isValidSourceFileName(const std::filesystem::path& path);
+bool passOne_ProcessOneFile(const std::filesystem::path& path);
 
-boost::filesystem::path relativeToCompileDir(const boost::filesystem::path&);
+std::filesystem::path relativeToCompileDir(const std::filesystem::path&);
 
 void initLexer();
 
--- a/lang/LangSource/PyrParseNode.cpp
+++ b/lang/LangSource/PyrParseNode.cpp
@@ -41,7 +41,7 @@
 #include "SC_LanguageConfig.hpp"
 #include "SC_Codecvt.hpp"
 
-namespace bfs = boost::filesystem;
+namespace fs = std::filesystem;
 
 AdvancingAllocPool gParseNodePool;
 
@@ -289,7 +289,7 @@ PyrClassExtNode* newPyrClassExtNode(PyrSlotNode* className, PyrMethodNode* metho
 void PyrClassExtNode::compile(PyrSlot* result) {
     PyrClass* classobj = slotRawSymbol(&mClassName->mSlot)->u.classobj;
     if (!classobj) {
-        const bfs::path relpath = relativeToCompileDir(bfs::path(gCompilingFileSym->name));
+        const fs::path relpath = relativeToCompileDir(fs::path(gCompilingFileSym->name));
         error("Class extension for nonexistent class '%s'\n     In file:'%s'\n",
               slotRawSymbol(&mClassName->mSlot)->name, SC_Codecvt::path_to_utf8_str(relpath).c_str());
         return;
--- a/lang/LangSource/SC_LanguageConfig.cpp
+++ b/lang/LangSource/SC_LanguageConfig.cpp
@@ -29,8 +29,8 @@
 #include <algorithm> // std::find
 #include <functional> // std::function
 
-#include <boost/filesystem/operations.hpp> // exists (, canonical?)
-#include <boost/filesystem/fstream.hpp> // ofstream
+#include <filesystem>
+#include <fstream>
 #include <yaml-cpp/yaml.h> // YAML
 
 SC_LanguageConfig::Path SC_LanguageConfig::gConfigFile;
@@ -46,7 +46,7 @@ const char* SCLANG_YAML_CONFIG_FILENAME = "sclang_conf.yaml";
 static const char* EXCLUDE_DEFAULT_PATHS = "excludeDefaultPaths";
 
 using DirName = SC_Filesystem::DirName;
-namespace bfs = boost::filesystem;
+namespace fs = std::filesystem;
 
 void SC_LanguageConfig::setExcludeDefaultPaths(bool value) {
     if (mExcludeDefaultPaths != value) {
@@ -104,13 +104,13 @@ bool SC_LanguageConfig::removeIncludedDirectory(const Path& path) { return remov
 bool SC_LanguageConfig::removeExcludedDirectory(const Path& path) { return removePath(mExcludedDirectories, path); }
 
 static void processPathList(const char* nodeName, YAML::Node& doc,
-                            const std::function<void(const boost::filesystem::path&)>& func) {
+                            const std::function<void(const std::filesystem::path&)>& func) {
     const YAML::Node& items = doc[nodeName];
     if (items && items.IsSequence()) {
         for (auto const& item : items) {
             const std::string& path = item.as<std::string>("");
             if (!path.empty()) {
-                const boost::filesystem::path& native_path = SC_Codecvt::utf8_str_to_path(path);
+                const std::filesystem::path& native_path = SC_Codecvt::utf8_str_to_path(path);
                 func(native_path);
             }
         }
@@ -138,7 +138,7 @@ bool SC_LanguageConfig::readLibraryConfigYAML(const Path& fileName, bool standal
 
     using namespace YAML;
     try {
-        bfs::ifstream fin(fileName);
+        std::ifstream fin(fileName);
         Node doc = Load(fin);
         if (doc) {
             processBool(
@@ -160,7 +160,7 @@ bool SC_LanguageConfig::readLibraryConfigYAML(const Path& fileName, bool standal
 }
 
 bool SC_LanguageConfig::writeLibraryConfigYAML(const Path& fileName) {
-    if (!bfs::exists(fileName.parent_path()))
+    if (!fs::exists(fileName.parent_path()))
         return false;
 
     using namespace YAML;
@@ -174,13 +174,13 @@ bool SC_LanguageConfig::writeLibraryConfigYAML(const Path& fileName) {
 
     out << Key << INCLUDE_PATHS;
     out << Value << BeginSeq;
-    for (const bfs::path& it : gLanguageConfig->mIncludedDirectories)
+    for (const fs::path& it : gLanguageConfig->mIncludedDirectories)
         out << SC_Codecvt::path_to_utf8_str(it);
     out << EndSeq;
 
     out << Key << EXCLUDE_PATHS;
     out << Value << BeginSeq;
-    for (const bfs::path& it : gLanguageConfig->mExcludedDirectories)
+    for (const fs::path& it : gLanguageConfig->mExcludedDirectories)
         out << SC_Codecvt::path_to_utf8_str(it);
     out << EndSeq;
 
@@ -192,7 +192,7 @@ bool SC_LanguageConfig::writeLibraryConfigYAML(const Path& fileName) {
 
     out << EndMap;
 
-    bfs::ofstream fout(fileName);
+    std::ofstream fout(fileName);
     fout << out.c_str();
     return fout.good();
 }
@@ -207,20 +207,20 @@ bool SC_LanguageConfig::defaultLibraryConfig(bool standalone) {
 bool SC_LanguageConfig::readLibraryConfig(bool standalone) {
     bool configured = false;
 
-    if (bfs::exists(gConfigFile))
+    if (fs::exists(gConfigFile))
         configured = readLibraryConfigYAML(gConfigFile, standalone);
 
     if (!configured && !standalone) {
         const Path userYamlConfigFile =
             SC_Filesystem::instance().getDirectory(DirName::UserConfig) / SCLANG_YAML_CONFIG_FILENAME;
 
-        if (bfs::exists(userYamlConfigFile))
+        if (fs::exists(userYamlConfigFile))
             configured = readLibraryConfigYAML(userYamlConfigFile, standalone);
 
         if (!configured) {
             const Path globalYamlConfigFile = Path("/etc") / SCLANG_YAML_CONFIG_FILENAME;
 
-            if (bfs::exists(globalYamlConfigFile))
+            if (fs::exists(globalYamlConfigFile))
                 configured = readLibraryConfigYAML(globalYamlConfigFile, standalone);
         }
     }
--- a/lang/LangSource/SC_LanguageConfig.hpp
+++ b/lang/LangSource/SC_LanguageConfig.hpp
@@ -25,7 +25,7 @@
 
 #include <vector>
 #include <string>
-#include <boost/filesystem/path.hpp>
+#include <filesystem>
 
 class SC_LanguageConfig;
 extern SC_LanguageConfig* gLanguageConfig;
@@ -42,7 +42,7 @@ extern const char* SCLANG_YAML_CONFIG_FILENAME;
  */
 class SC_LanguageConfig {
 public:
-    typedef boost::filesystem::path Path;
+    typedef std::filesystem::path Path;
     typedef std::vector<Path> DirVector;
 
     const DirVector& includedDirectories() const { return mIncludedDirectories; }
--- a/lang/LangSource/SC_TerminalClient.cpp
+++ b/lang/LangSource/SC_TerminalClient.cpp
@@ -61,7 +61,7 @@
 #include "SC_LanguageConfig.hpp"
 #include "SC_Version.hpp"
 
-#include <boost/filesystem/operations.hpp>
+#include <filesystem>
 
 using namespace boost::placeholders;
 
@@ -255,8 +255,7 @@ int SC_TerminalClient::run(int argc, char** argv) {
 
     // Create config directory so that it can be used by Quarks, etc. See #2919.
     if (!opt.mStandalone && !opt.mLibraryConfigFile)
-        boost::filesystem::create_directories(
-            SC_Filesystem::instance().getDirectory(SC_Filesystem::DirName::UserConfig));
+        std::filesystem::create_directories(SC_Filesystem::instance().getDirectory(SC_Filesystem::DirName::UserConfig));
 
     // startup library
     compileLibrary(opt.mStandalone);
--- a/server/scsynth/SC_GraphDef.cpp
+++ b/server/scsynth/SC_GraphDef.cpp
@@ -45,10 +45,10 @@
 #include <stdexcept>
 #include <string>
 
-#include <boost/filesystem/operations.hpp> // recursive_directory_iterator
-#include "boost_string_file.hpp" // load_string_file
+#include <filesystem>
+#include <fstream>
 
-namespace bfs = boost::filesystem;
+namespace fs = std::filesystem;
 
 extern Malloc gMalloc;
 
@@ -601,7 +601,7 @@ GraphDef* GraphDef_LoadGlob(World* inWorld, const char* pattern, GraphDef* inLis
     if (!glob)
         return inList;
 
-    bfs::path path;
+    fs::path path;
     while (!(path = SC_Filesystem::globNext(glob)).empty()) {
         if (path.extension() == ".scsyndef") {
             inList = GraphDef_Load(inWorld, path, inList);
@@ -614,10 +614,19 @@ GraphDef* GraphDef_LoadGlob(World* inWorld, const char* pattern, GraphDef* inLis
     return inList;
 }
 
-GraphDef* GraphDef_Load(World* inWorld, const bfs::path& path, GraphDef* inList) {
+std::string load_file(const std::filesystem::path& file_path) {
+    std::ifstream file(file_path);
+    if (!file.is_open()) {
+        throw std::runtime_error("Could not open file: " + file_path.string());
+    }
+    std::stringstream buffer;
+    buffer << file.rdbuf();
+    return buffer.str();
+}
+
+GraphDef* GraphDef_Load(World* inWorld, const fs::path& path, GraphDef* inList) {
     try {
-        std::string file_contents;
-        bfs::load_string_file(path, file_contents);
+        std::string file_contents = load_file(path);
         inList = GraphDefLib_Read(inWorld, &file_contents[0], inList);
     } catch (const std::exception& e) {
         scprintf("exception in GraphDef_Load: %s\n", e.what());
@@ -632,21 +641,21 @@ GraphDef* GraphDef_Load(World* inWorld, const bfs::path& path, GraphDef* inList)
     return inList;
 }
 
-GraphDef* GraphDef_LoadDir(World* inWorld, const bfs::path& dirname, GraphDef* inList) {
-    boost::system::error_code ec;
-    bfs::recursive_directory_iterator rditer(dirname, bfs::symlink_option::recurse, ec);
+GraphDef* GraphDef_LoadDir(World* inWorld, const fs::path& dirname, GraphDef* inList) {
+    std::error_code ec;
+    fs::recursive_directory_iterator rditer(dirname, fs::directory_options::follow_directory_symlink, ec);
 
     if (ec) {
         scprintf("*** ERROR: open directory failed '%s'\n", SC_Codecvt::path_to_utf8_str(dirname).c_str());
         return inList;
     }
 
-    while (rditer != bfs::end(rditer)) {
-        const bfs::path path = *rditer;
+    while (rditer != fs::end(rditer)) {
+        const fs::path path = *rditer;
 
-        if (bfs::is_directory(path)) {
+        if (fs::is_directory(path)) {
             if (SC_Filesystem::instance().shouldNotCompileDirectory(path))
-                rditer.no_push();
+                rditer.disable_recursion_pending();
             else
                 ; // do nothing; recursion will happen automatically
         } else if (path.extension() == ".scsyndef") { // ordinary file
--- a/server/scsynth/SC_GraphDef.h
+++ b/server/scsynth/SC_GraphDef.h
@@ -22,7 +22,7 @@
 
 #include "SC_SynthDef.h"
 #include "HashTable.h"
-#include <boost/filesystem/path.hpp> // path
+#include <filesystem>
 
 struct ParamSpec {
     int32 mName[kSCNameLen];
@@ -71,8 +71,8 @@ struct GraphDef {
 typedef struct GraphDef GraphDef;
 
 GraphDef* GraphDef_Recv(World* inWorld, char* buffer, GraphDef* inList);
-GraphDef* GraphDef_Load(struct World* inWorld, const boost::filesystem::path& path, GraphDef* inList);
-GraphDef* GraphDef_LoadDir(struct World* inWorld, const boost::filesystem::path& path, GraphDef* inList);
+GraphDef* GraphDef_Load(struct World* inWorld, const std::filesystem::path& path, GraphDef* inList);
+GraphDef* GraphDef_LoadDir(struct World* inWorld, const std::filesystem::path& path, GraphDef* inList);
 GraphDef* GraphDef_LoadGlob(World* inWorld, const char* pattern, GraphDef* inList);
 SCErr GraphDef_Remove(World* inWorld, int32* inName);
 SCErr GraphDef_DeleteMsg(struct World* inWorld, GraphDef* inDef);
--- a/server/scsynth/SC_Lib_Cintf.cpp
+++ b/server/scsynth/SC_Lib_Cintf.cpp
@@ -44,8 +44,7 @@
 #    include <sys/param.h>
 #endif // _WIN32
 
-#include <boost/filesystem/path.hpp> // path
-#include <boost/filesystem/operations.hpp> // is_directory
+#include <filesystem>
 
 #ifdef __APPLE__
 extern "C" {
@@ -55,7 +54,7 @@ extern "C" {
 char gTempVal;
 #endif // __APPLE__
 
-namespace bfs = boost::filesystem;
+namespace fs = std::filesystem;
 
 Malloc gMalloc;
 HashTable<SC_LibCmd, Malloc>* gCmdLib;
@@ -66,7 +65,7 @@ extern struct InterfaceTable gInterfaceTable;
 SC_LibCmd* gCmdArray[NUMBER_OF_COMMANDS];
 
 void initMiscCommands();
-static bool PlugIn_LoadDir(const bfs::path& dir, bool reportError);
+static bool PlugIn_LoadDir(const fs::path& dir, bool reportError);
 std::vector<void*> open_handles;
 #ifdef __APPLE__
 void read_section(const struct mach_header* mhp, unsigned long slide, const char* segname, const char* sectname) {
@@ -180,14 +179,14 @@ void initialize_library(const char* uGensPluginPath) {
     if (loadUGensExtDirs) {
 #ifdef SC_PLUGIN_DIR
         // load globally installed plugins
-        if (bfs::is_directory(SC_PLUGIN_DIR)) {
+        if (fs::is_directory(SC_PLUGIN_DIR)) {
             PlugIn_LoadDir(SC_PLUGIN_DIR, true);
         }
 #endif // SC_PLUGIN_DIR
        // load default plugin directory
-        const bfs::path pluginDir = SC_Filesystem::instance().getDirectory(DirName::Resource) / SC_PLUGIN_DIR_NAME;
+        const fs::path pluginDir = SC_Filesystem::instance().getDirectory(DirName::Resource) / SC_PLUGIN_DIR_NAME;
 
-        if (bfs::is_directory(pluginDir)) {
+        if (fs::is_directory(pluginDir)) {
             PlugIn_LoadDir(pluginDir, true);
         }
     }
@@ -195,11 +194,11 @@ void initialize_library(const char* uGensPluginPath) {
     // get extension directories
     if (loadUGensExtDirs) {
         // load system extension plugins
-        const bfs::path sysExtDir = SC_Filesystem::instance().getDirectory(DirName::SystemExtension);
+        const fs::path sysExtDir = SC_Filesystem::instance().getDirectory(DirName::SystemExtension);
         PlugIn_LoadDir(sysExtDir, false);
 
         // load user extension plugins
-        const bfs::path userExtDir = SC_Filesystem::instance().getDirectory(DirName::UserExtension);
+        const fs::path userExtDir = SC_Filesystem::instance().getDirectory(DirName::UserExtension);
         PlugIn_LoadDir(userExtDir, false);
 
         // load user plugin directories
@@ -281,7 +280,7 @@ bool checkServerVersion(void* f, const char* filename) {
     return true;
 }
 
-static bool PlugIn_Load(const bfs::path& filename) {
+static bool PlugIn_Load(const fs::path& filename) {
 #ifdef _WIN32
     HINSTANCE hinstance = LoadLibraryW(filename.wstring().c_str());
     // here, we have to use a utf-8 version of the string for printing
@@ -365,9 +364,9 @@ static bool PlugIn_Load(const bfs::path& filename) {
 #endif // _WIN32
 }
 
-static bool PlugIn_LoadDir(const bfs::path& dir, bool reportError) {
-    boost::system::error_code ec;
-    bfs::recursive_directory_iterator rditer(dir, bfs::symlink_option::recurse, ec);
+static bool PlugIn_LoadDir(const fs::path& dir, bool reportError) {
+    std::error_code ec;
+    fs::recursive_directory_iterator rditer(dir, fs::directory_options::follow_directory_symlink, ec);
 
     if (ec) {
         if (reportError) {
@@ -378,12 +377,12 @@ static bool PlugIn_LoadDir(const bfs::path& dir, bool reportError) {
         return false;
     }
 
-    while (rditer != bfs::end(rditer)) {
-        const bfs::path path = *rditer;
+    while (rditer != fs::end(rditer)) {
+        const fs::path path = *rditer;
 
-        if (bfs::is_directory(path)) {
+        if (fs::is_directory(path)) {
             if (SC_Filesystem::instance().shouldNotCompileDirectory(path))
-                rditer.no_push();
+                rditer.disable_recursion_pending();
             else
                 ; // do nothing; recursion for free
         } else if (path.extension() == SC_PLUGIN_EXT) {
--- a/server/scsynth/SC_SequencedCommand.cpp
+++ b/server/scsynth/SC_SequencedCommand.cpp
@@ -30,8 +30,7 @@
 #include "../../common/SC_SndFileHelpers.hpp"
 #include "SC_WorldOptions.h"
 
-/* boost headers */
-#include <boost/filesystem.hpp>
+#include <filesystem>
 
 const size_t ERR_BUF_SIZE(512);
 
@@ -1407,7 +1406,7 @@ LoadSynthDefDirCmd::~LoadSynthDefDirCmd() { World_Free(mWorld, mFilename); }
 void LoadSynthDefDirCmd::CallDestructor() { this->~LoadSynthDefDirCmd(); }
 
 bool LoadSynthDefDirCmd::Stage2() {
-    if (!boost::filesystem::exists(mFilename)) {
+    if (!std::filesystem::exists(mFilename)) {
         char str[ERR_BUF_SIZE];
         snprintf(str, ERR_BUF_SIZE, "Could not load synthdefs. Directory '%s' does not exist\n", mFilename);
         SendFailure(&mReplyAddress, "/d_loadDir", mFilename);
--- a/server/scsynth/SC_World.cpp
+++ b/server/scsynth/SC_World.cpp
@@ -75,9 +75,9 @@
 
 #include "server_shm.hpp"
 
-#include <boost/filesystem/path.hpp> // path
+#include <filesystem>
 
-namespace bfs = boost::filesystem;
+namespace fs = std::filesystem;
 
 InterfaceTable gInterfaceTable;
 PrintFunc gPrint = nullptr;
@@ -271,7 +271,7 @@ void World_LoadGraphDefs(World* world) {
             GraphDef_Define(world, list);
         }
     } else {
-        bfs::path path = SC_Filesystem::instance().getDirectory(DirName::UserAppSupport) / "synthdefs";
+        fs::path path = SC_Filesystem::instance().getDirectory(DirName::UserAppSupport) / "synthdefs";
         if (world->mVerbosity > 0)
             scprintf("Loading synthdefs from default path: %s\n", SC_Codecvt::path_to_utf8_str(path).c_str());
         list = GraphDef_LoadDir(world, path, list);
--- a/server/supernova/sc/sc_synth_definition.cpp
+++ b/server/supernova/sc/sc_synth_definition.cpp
@@ -19,7 +19,7 @@
 #include <iostream>
 #include <future>
 
-#include <boost/filesystem/operations.hpp>
+#include <filesystem>
 #include <boost/range/iterator_range.hpp>
 
 #include "sc_synth.hpp"
@@ -49,7 +49,7 @@ std::vector<sc_synthdef> sc_read_synthdefs_file(path const& file) {
 }
 
 std::vector<sc_synthdef> sc_read_synthdefs_dir(path const& dir) {
-    using namespace boost::filesystem;
+    using namespace std::filesystem;
     using namespace std;
 
     typedef vector<sc_synthdef> def_vector;
--- a/server/supernova/sc/sc_synth_definition.hpp
+++ b/server/supernova/sc/sc_synth_definition.hpp
@@ -18,7 +18,7 @@
 
 #pragma once
 
-#include <boost/filesystem/path.hpp>
+#include <filesystem>
 
 #include "sc_synthdef.hpp"
 
@@ -27,7 +27,7 @@
 
 namespace nova {
 
-using boost::filesystem::path;
+using std::filesystem::path;
 
 /* read synthdefs from path pattern */
 std::vector<sc_synthdef> sc_read_synthdefs_file(path const& filename);
--- a/server/supernova/sc/sc_synthdef.cpp
+++ b/server/supernova/sc/sc_synthdef.cpp
@@ -137,7 +137,7 @@ std::vector<sc_synthdef> read_synthdefs(const char* buffer, const char* buffer_e
     return ret;
 }
 
-std::vector<sc_synthdef> read_synthdef_file(boost::filesystem::path const& filename) {
+std::vector<sc_synthdef> read_synthdef_file(std::filesystem::path const& filename) {
     using namespace std;
 
     ifstream stream;
--- a/server/supernova/sc/sc_synthdef.hpp
+++ b/server/supernova/sc/sc_synthdef.hpp
@@ -22,9 +22,9 @@
 #include <map>
 #include <string>
 #include <vector>
+#include <filesystem>
 
 #include <boost/align/aligned_allocator.hpp>
-#include <boost/filesystem/path.hpp>
 
 #include "utilities/named_hash_entry.hpp"
 
@@ -134,6 +134,6 @@ private:
 };
 
 std::vector<sc_synthdef> read_synthdefs(const char* buffer, const char* buffer_end);
-std::vector<sc_synthdef> read_synthdef_file(boost::filesystem::path const& filename);
+std::vector<sc_synthdef> read_synthdef_file(std::filesystem::path const& filename);
 
 } /* namespace nova */
--- a/server/supernova/sc/sc_ugen_factory.cpp
+++ b/server/supernova/sc/sc_ugen_factory.cpp
@@ -25,7 +25,7 @@
 #    include "SC_Win32Utils.h"
 #endif
 
-#include <boost/filesystem.hpp>
+#include <filesystem>
 
 #include "sc_ugen_factory.hpp"
 
@@ -215,8 +215,8 @@ bool sc_plugin_container::run_cmd_plugin(World* world, const char* name, struct
 }
 
 
-void sc_ugen_factory::load_plugin_folder(boost::filesystem::path const& path) {
-    using namespace boost::filesystem;
+void sc_ugen_factory::load_plugin_folder(std::filesystem::path const& path) {
+    using namespace std::filesystem;
 
     directory_iterator end;
 
@@ -249,7 +249,7 @@ static bool check_api_version(int (*api_version)(), std::string const& filename)
 }
 
 #ifdef DLOPEN
-void sc_ugen_factory::load_plugin(boost::filesystem::path const& path) {
+void sc_ugen_factory::load_plugin(std::filesystem::path const& path) {
     using namespace std;
 
     // Ignore files that don't have the extension of an SC plugin
@@ -305,7 +305,7 @@ void sc_ugen_factory::close_handles(void) {
 
 #elif defined(_WIN32)
 
-void sc_ugen_factory::load_plugin(boost::filesystem::path const& path) {
+void sc_ugen_factory::load_plugin(std::filesystem::path const& path) {
     // Ignore files that don't have the extension of an SC plugin
     if (path.extension() != SC_PLUGIN_EXT) {
         return;
--- a/server/supernova/sc/sc_ugen_factory.hpp
+++ b/server/supernova/sc/sc_ugen_factory.hpp
@@ -177,8 +177,8 @@ public:
     uint32_t ugen_count(void) const { return ugen_count_; }
     /* @} */
 
-    void load_plugin_folder(boost::filesystem::path const& path);
-    void load_plugin(boost::filesystem::path const& path);
+    void load_plugin_folder(std::filesystem::path const& path);
+    void load_plugin(std::filesystem::path const& path);
 
 private:
     void close_handles(void);
--- a/server/supernova/server/main.cpp
+++ b/server/supernova/server/main.cpp
@@ -25,7 +25,7 @@
 #include "SC_Win32Utils.h"
 #include "SC_ServerBootDelayWarning.h"
 
-#include <boost/filesystem/path.hpp>
+#include <filesystem>
 #include <boost/algorithm/string.hpp>
 
 #include "server.hpp"
--- a/testsuite/server/supernova/sc_plugin_loader_test.cpp
+++ b/testsuite/server/supernova/sc_plugin_loader_test.cpp
@@ -2,7 +2,7 @@
 
 #include <iostream>
 
-#include <boost/filesystem.hpp>
+#include <filesystem>
 
 #include "sc/sc_ugen_factory.hpp"
 #include "server/memory_pool.hpp"
@@ -11,7 +11,7 @@
 using namespace nova;
 using namespace std;
 
-boost::filesystem::path base_path("/home/tim/workspace/nova-server/debug_plugins/");
+std::filesystem::path base_path("/home/tim/workspace/nova-server/debug_plugins/");
 
 BOOST_AUTO_TEST_CASE(ugen_factory_test_1) {
     server_arguments::initialize(0, 0);