From 1b9a5957a2096ac2811ae4c5e2693f97f645c3ef Mon Sep 17 00:00:00 2001 From: Kevin Mihelich Date: Mon, 2 Sep 2024 19:28:27 +0000 Subject: [PATCH] extra/supercollider to 3.13.0-7 --- extra/supercollider/.SRCINFO | 8 +- extra/supercollider/PKGBUILD | 18 +- extra/supercollider/boost-1.84.patch | 110 +++ extra/supercollider/boost-1.85.patch | 1336 ++++++++++++++++++++++++++ 4 files changed, 1468 insertions(+), 4 deletions(-) create mode 100644 extra/supercollider/boost-1.84.patch create mode 100644 extra/supercollider/boost-1.85.patch diff --git a/extra/supercollider/.SRCINFO b/extra/supercollider/.SRCINFO index 1ca906cfc..aa66cf4fb 100644 --- a/extra/supercollider/.SRCINFO +++ b/extra/supercollider/.SRCINFO @@ -1,7 +1,7 @@ pkgbase = supercollider pkgdesc = Platform for audio synthesis and algorithmic composition pkgver = 3.13.0 - pkgrel = 6 + pkgrel = 7 url = https://supercollider.github.io install = supercollider.install arch = x86_64 @@ -37,11 +37,17 @@ pkgbase = supercollider provides = scsynth=3.13.0 source = https://github.com/supercollider/supercollider/releases/download/Version-3.13.0/SuperCollider-3.13.0-Source.tar.bz2 source = https://github.com/supercollider/supercollider/releases/download/Version-3.13.0/SuperCollider-3.13.0-Source.tar.bz2.asc + source = boost-1.84.patch + source = boost-1.85.patch validpgpkeys = 2E1C4FC2F6BB58FA157B21B8064B501EB7405F04 sha512sums = a60a128f7646f077f91adae666fa4014529aa9df78cf0dfe5d68c9bd6447f008af7da2970b8736f3f29d0adbaf67bce680a8201fcbe7e1aba29c3499a57f89cd sha512sums = SKIP + sha512sums = 1b530d60570729a0b4dd13fbb9059b45288d4ff71391db6290b5e686985ad749267252c15eb63c81bf7bc01ca1141c163e3c7e30e6de1fc43c7b26ed66ab20cf + sha512sums = aabf9c44d5953adff7ee3f38d8d41b3b7dc2bdd4a498fb55df0aef66786f820ce5436accff44c7498743fe3ebbcc75549ec00769fe8269ea1f556419a93c16d9 b2sums = a5e57a17f93e40848b2044ee0791179f857d144eabb7f4d74580b2eebd49a31d6ec671a0526236c5b906aadeb455e5a7ad18cacb79ed214076d6bceca39ea2ae b2sums = SKIP + b2sums = 3c333d4b0b63d2c67167be6abe954a843cdd4c73b3cc28a9d7e011162dbb3ddf475ad75f03a780abb7cbf8a54ee0b308e02a7a752532f5f1c110a1e3d8152753 + b2sums = 42b76de099a42643e107f8152fd6ba050771d938d89885c5e46d4e07d3e94d03c57cb4eefa0cd38c52f7cbfbf96fefa0101532cd64cd1efce8e2e76604ab99f0 pkgname = supercollider depends = gcc-libs diff --git a/extra/supercollider/PKGBUILD b/extra/supercollider/PKGBUILD index 29ddef60d..589e5ef6b 100644 --- a/extra/supercollider/PKGBUILD +++ b/extra/supercollider/PKGBUILD @@ -9,7 +9,7 @@ _name=SuperCollider pkgname=supercollider pkgver=3.13.0 -pkgrel=6 +pkgrel=7 pkgdesc="Platform for audio synthesis and algorithmic composition" arch=(x86_64) url="https://supercollider.github.io" @@ -51,14 +51,26 @@ optdepends=( provides=(libscsynth.so "sclang=$pkgver" "scsynth=$pkgver") source=( https://github.com/$pkgname/$pkgname/releases/download/Version-$pkgver/$_name-$pkgver-Source.tar.bz2{,.asc} + boost-1.84.patch + boost-1.85.patch ) install=$pkgname.install sha512sums=('a60a128f7646f077f91adae666fa4014529aa9df78cf0dfe5d68c9bd6447f008af7da2970b8736f3f29d0adbaf67bce680a8201fcbe7e1aba29c3499a57f89cd' - 'SKIP') + 'SKIP' + '1b530d60570729a0b4dd13fbb9059b45288d4ff71391db6290b5e686985ad749267252c15eb63c81bf7bc01ca1141c163e3c7e30e6de1fc43c7b26ed66ab20cf' + 'aabf9c44d5953adff7ee3f38d8d41b3b7dc2bdd4a498fb55df0aef66786f820ce5436accff44c7498743fe3ebbcc75549ec00769fe8269ea1f556419a93c16d9') b2sums=('a5e57a17f93e40848b2044ee0791179f857d144eabb7f4d74580b2eebd49a31d6ec671a0526236c5b906aadeb455e5a7ad18cacb79ed214076d6bceca39ea2ae' - 'SKIP') + 'SKIP' + '3c333d4b0b63d2c67167be6abe954a843cdd4c73b3cc28a9d7e011162dbb3ddf475ad75f03a780abb7cbf8a54ee0b308e02a7a752532f5f1c110a1e3d8152753' + '42b76de099a42643e107f8152fd6ba050771d938d89885c5e46d4e07d3e94d03c57cb4eefa0cd38c52f7cbfbf96fefa0101532cd64cd1efce8e2e76604ab99f0') validpgpkeys=('2E1C4FC2F6BB58FA157B21B8064B501EB7405F04') # Marcin Pączkowski (dyfer) +prepare() { + cd $_name-$pkgver-Source +# Patches from Gentoo + patch -p1 -i ../boost-1.84.patch + patch -p1 -i ../boost-1.85.patch +} build() { local cmake_options=( diff --git a/extra/supercollider/boost-1.84.patch b/extra/supercollider/boost-1.84.patch new file mode 100644 index 000000000..d3b2340a3 --- /dev/null +++ b/extra/supercollider/boost-1.84.patch @@ -0,0 +1,110 @@ +From 6e4e12826fd144c874c93c2efb669fbb119b831a Mon Sep 17 00:00:00 2001 +From: Andreas Sturmlechner +Date: Tue, 30 Jan 2024 23:56:14 +0100 +Subject: [PATCH] Import boost_string_file.hpp from boost-1.83 and put it to + use immediately + +string_file.hpp was deprecated in boost-1.79.0 and removed in 1.84.0 + +Signed-off-by: Andreas Sturmlechner +--- + common/boost_string_file.hpp | 59 ++++++++++++++++++++++++++++++++++ + lang/LangSource/PyrLexer.cpp | 2 +- + server/scsynth/SC_GraphDef.cpp | 2 +- + 3 files changed, 61 insertions(+), 2 deletions(-) + create mode 100644 common/boost_string_file.hpp + +diff --git a/common/boost_string_file.hpp b/common/boost_string_file.hpp +new file mode 100644 +index 000000000..1ccb63de6 +--- /dev/null ++++ b/common/boost_string_file.hpp +@@ -0,0 +1,59 @@ ++// filesystem/string_file.hpp --------------------------------------------------------// ++ ++// Copyright Beman Dawes 2015 ++ ++// Distributed under the Boost Software License, Version 1.0. ++// See http://www.boost.org/LICENSE_1_0.txt ++ ++// Library home page: http://www.boost.org/libs/filesystem ++ ++#ifndef BOOST_FILESYSTEM_STRING_FILE_HPP ++#define BOOST_FILESYSTEM_STRING_FILE_HPP ++ ++#include ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#include // must be the last #include ++ ++namespace boost { ++namespace filesystem { ++ ++inline void save_string_file(path const& p, std::string const& str) ++{ ++ filesystem::ofstream file; ++ file.exceptions(std::ios_base::failbit | std::ios_base::badbit); ++ file.open(p, std::ios_base::binary); ++ const std::size_t sz = str.size(); ++ if (BOOST_UNLIKELY(sz > static_cast< boost::uintmax_t >((std::numeric_limits< std::streamsize >::max)()))) ++ BOOST_FILESYSTEM_THROW(std::length_error("String size exceeds max write size")); ++ file.write(str.c_str(), static_cast< std::streamsize >(sz)); ++} ++ ++inline void load_string_file(path const& p, std::string& str) ++{ ++ filesystem::ifstream file; ++ file.exceptions(std::ios_base::failbit | std::ios_base::badbit); ++ file.open(p, std::ios_base::binary); ++ const boost::uintmax_t sz = filesystem::file_size(p); ++ if (BOOST_UNLIKELY(sz > static_cast< boost::uintmax_t >((std::numeric_limits< std::streamsize >::max)()))) ++ BOOST_FILESYSTEM_THROW(std::length_error("File size exceeds max read size")); ++ str.resize(static_cast< std::size_t >(sz), '\0'); ++ if (sz > 0u) ++ file.read(&str[0], static_cast< std::streamsize >(sz)); ++} ++ ++} // namespace filesystem ++} // namespace boost ++ ++#include ++ ++#endif // BOOST_FILESYSTEM_STRING_FILE_HPP +diff --git a/lang/LangSource/PyrLexer.cpp b/lang/LangSource/PyrLexer.cpp +index 7ebe3d726..06c1454ca 100644 +--- a/lang/LangSource/PyrLexer.cpp ++++ b/lang/LangSource/PyrLexer.cpp +@@ -38,7 +38,7 @@ + + #include + #include +-#include ++#include "boost_string_file.hpp" + + #include "PyrParseNode.h" + #include "Bison/lang11d_tab.h" +diff --git a/server/scsynth/SC_GraphDef.cpp b/server/scsynth/SC_GraphDef.cpp +index 957aca193..5f8f15741 100644 +--- a/server/scsynth/SC_GraphDef.cpp ++++ b/server/scsynth/SC_GraphDef.cpp +@@ -46,7 +46,7 @@ + #include + + #include // recursive_directory_iterator +-#include // load_string_file ++#include "boost_string_file.hpp" // load_string_file + + namespace bfs = boost::filesystem; + +-- +2.43.0 + diff --git a/extra/supercollider/boost-1.85.patch b/extra/supercollider/boost-1.85.patch new file mode 100644 index 000000000..08d15cd18 --- /dev/null +++ b/extra/supercollider/boost-1.85.patch @@ -0,0 +1,1336 @@ +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 +-#include // path ++#include + + #ifdef _WIN32 + # include // 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()); ++ return std::wstring_convert>().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()); ++ std::wstring_convert> 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 + #include // std::transform + #include // std::string +-#include // path ++#include // 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 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 // path, parent_path() +-# include // canonical, current_path() ++# include // path, parent_path(), canonical, current_path() + + // system includes + # include +@@ -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 // is_directory ++# include + + // system + # include // 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 // path ++#include + + 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 +- +-/* boost headers */ +-#include ++#include + + /* 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(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 // path ++#include + #include + +-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 // path ++#include + + #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 + #include + #include +-#include // ifstream +-#include // path ++ ++#include ++#include + + #include + + 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 paths; ++ std::vector 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 + #include + #include ++#include + + #include + #include +@@ -46,7 +46,7 @@ Primitives for Unix. + + #include "SC_Lock.h" + +-#include ++#include + + #ifdef _WIN32 + # include "SC_Win32Utils.h" +@@ -54,7 +54,7 @@ Primitives for Unix. + # include + #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 + #endif + +-#include +-#include +-#include "boost_string_file.hpp" ++#include ++#include + + #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 compiledDirectories; ++std::set 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 ++#include + + 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 // std::find + #include // std::function + +-#include // exists (, canonical?) +-#include // ofstream ++#include ++#include + #include // 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& func) { ++ const std::function& func) { + const YAML::Node& items = doc[nodeName]; + if (items && items.IsSequence()) { + for (auto const& item : items) { + const std::string& path = item.as(""); + 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 + #include +-#include ++#include + + 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 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 ++#include + + 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 + #include + +-#include // recursive_directory_iterator +-#include "boost_string_file.hpp" // load_string_file ++#include ++#include + +-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 // path ++#include + + 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 + #endif // _WIN32 + +-#include // path +-#include // is_directory ++#include + + #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* 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 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 ++#include + + 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 // path ++#include + +-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 + #include + +-#include ++#include + #include + + #include "sc_synth.hpp" +@@ -49,7 +49,7 @@ std::vector sc_read_synthdefs_file(path const& file) { + } + + std::vector sc_read_synthdefs_dir(path const& dir) { +- using namespace boost::filesystem; ++ using namespace std::filesystem; + using namespace std; + + typedef vector 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 ++#include + + #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_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 read_synthdefs(const char* buffer, const char* buffer_e + return ret; + } + +-std::vector read_synthdef_file(boost::filesystem::path const& filename) { ++std::vector 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 + #include + #include ++#include + + #include +-#include + + #include "utilities/named_hash_entry.hpp" + +@@ -134,6 +134,6 @@ private: + }; + + std::vector read_synthdefs(const char* buffer, const char* buffer_end); +-std::vector read_synthdef_file(boost::filesystem::path const& filename); ++std::vector 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 ++#include + + #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 ++#include + #include + + #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 + +-#include ++#include + + #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);