How similar are Boost.Filesystem and the C++ standard filesystem library?

I need a filesystem library for use with a C++11-capable compiler or a C++14-capable one - so it can't be be from C++17.

Now, I know that the filesystem library going into C++17 is based based on Boost::Filesystem; but - are they similar enough for me to use the Boost library and then seamlessly switch to the standard version at a later time, without changing more than, say, a using statement? Or are there (minor/significant) differences between the two? I know that for the case of variant, the Boost and the standard library versions differ quite a bit.

There are a number of differences. Some were, I believe, Boost changes that were never propagated. For example, there is no path.filename_is_dot() query (as discussed below, it would be less useful in std::filesystem anyway).

There was also a good bit of late-breaking news on this front:

1. Support for non-POSIX-like filesystems:
   • Specify whether a string is OS-native or POSIX-like (or let the implementation decide, which is (still) the default)
   • An implementation may define additional file types (beyond regular, directory, socket, etc.)
   • An implementation may define file_size for a directory or device file
2. filename(), normalization, and relative/absolute conversions redefined (examples for POSIX):
   • path("foo/.").lexically_normal()=="foo/" (is the opposite in Boost)
   • path("foo/").filename()=="" (is path(".") in Boost)
   • remove_filename() leaves the trailing slash and is thus idempotent (it assigns parent_path() in Boost)
   • path(".profile").extension()=="" (is the whole name in Boost)
   • path decompositions and combinations can preserve things like alternate data stream names that are normally invisible
   • path("foo")/"/bar"=="/bar" (is path("foo/bar") in Boost), which allows composing relative file names with others (absolute or relative) and replaces Boost's absolute()
   • Boost's system_complete() (which takes only one argument) is renamed to absolute()
   • canonical() thus takes only one argument (fixed in a DR)
   • lexically_relative() handles .. and root elements correctly
   • permissions() takes more arguments (Boost combines them into a bitmask)

Note that Boost.Filesystem v4 is under development and is supposed to be C++17-compatible (but therefore incompatible in many respects with v3).