fast_io represents a cutting-edge input/output (I/O) library for C++20, designed to achieve exceptional speed. Its primary purpose is to supersede the widely used <iostream> and <cstdio> libraries. This header-only library is distributed under the permissive MIT license, simplifying integration into any project. However, its utilization mandates a C++20 compiler with support for concepts.

Although the original fast_io repository has been archived due to accumulated git data, historical commits remain accessible. Past commits were stored here.

#include <fast_io.h>

int main() {
	::fast_io::io::print("Hello, fast_io world!\n");
}

#include <fast_io.h>

int main() {
	::fast_io::native_file_loader file_data{"text.txt"};
	// file_data satisfies ::std::ranges::contiguous_range
}

For up-to-date examples, refer to the examples/ directories.

Outdated examples are retained here though they might no longer be functional.

The i18n repository houses the i18n source files.

https://bitbucket.org/ejsvifq_mabmip/fast_io_i18n

The term fast within fast_io does not strictly denote the absolute fastest I/O library available (which might have prompted the name fastest_io). Instead, it signifies that fast_io consistently surpasses the performance of both the <iostream> and <cstdio> libraries.

For a comprehensive list of supported elements and platform-specific usage instructions, consult support.md.

You can ask questions on the fast_io discord server or the QQ group: 801441303.

Refer to either https://ewindy.gitee.io/fast_io_rst/index.html or https://gitee.com/qabeowjbtkwb/fast_io/wikis.

• Utilizing system calls directly, bypassing intermediary layers for enhanced efficiency.
• Embraces Unicode (UTF-8, UTF-16, UTF-32) with codecvt for GB18030 and UTF-EBCDIC (as these aren't properly addressed by libcs).
• Implements RAII for C FILE*, POSIX fd, and win32/NT HANDLE.
• Facilitates interoperation with <cstdio> and <iostream>.
• Minimizes misuse potential, unlike std::endl.
• Employs static I/O manipulators in lieu of format strings.
• Offers optional locale support.
• Implements stateless I/O manipulation.
• Maintains consistent error handling, favoring exceptions as the sole error reporting mechanism (excluding std::error_code, std::system_error, and redundant bounds checking).
• Accommodates freestanding mode.
• Incorporates Address Sanitizer code for memory safety.
• Provides support for Dynamic Instrumentation.
• Supports POSIX iconv for transcoding.
• Provides binary serialization for trivially copyable types and standard containers.
• Integrates seamlessly with C++ containers (e.g., std::vector<fast_io::obuf_file> is valid).
• Supplies basic/Lua/Python/etc. formatting (print, scan), omitting C and C++ due to security concerns.
• Native Handle Interface
• Exposes APIs for the internal implementation of FILE* and C++ streams.
• Abstains from using traits_type and EOF.
• Encompasses Dynamic Type Support
• Facilitates Multi-Process functionality
• Supports memory mapping
• Features debugging I/O (with optional GUI)
• Employs a round-trip floating-point algorithm
• Supports hash algorithms: intrinsic SHA-1, intrinsic HMAC-SHA1, intrinsic SHA-256, intrinsic HMAC-SHA256, SHA-512, HMAC-SHA512, as well as non-crypto hash algorithms like Jenkins Hash.
• Provides zlib compression/decompression
• Offers Filesystem capabilities
• OpenSSL BIO, Qt QFile, MFC CFile support

1. Module support
2. Coroutine support for asynchronous I/O
3. Code improvement and refactoring following the integration of Zero-overhead deterministic exceptions into the standard

1. I/O for 10 Million Integers

Objective: Output ten million integers from 0 to 10M to a file and subsequently read them back from the same file.

All benchmark details are located in benchmarks/0000.10m_size_t/unit.

Note: I adjusted libstdc++'s BUFSIZ to 1048576 due to MinGW-W64's poor performance with the default BUFSIZ of 512 bytes. (Update: GCC has rectified this by further increasing the size to 4096)

Rust language is 10x slower than fast_io. + binary bloat and itoa library is still extremely slow and usable for me. It is at least 3x slower than fast_io.

Run the same test on MSVC 19.26.28805.

Run the same test on GCC 11. glibc + libstdc++

You can see fast_io can also boost the performance of existing facilities for 10x! Yes, it can even improve FILE* and fstream's performance for 10x depending on platforms since I use concepts to abstract them all. fmtlib actually slows down I/O performance.

2. Output 10M double in round-trip mode with Ryu algorithm

We only perform this test for MSVC since only msvc's charconv implements it. Yes. fast_io defeats msvc's charconv for over 20% for running the same algorithm.

All benchmarks are in benchmarks/0001.10m_double/charconv.

Run the same test on MSVC 19.26.28805.

3. Raw I/O Performance

All benchmarks are in benchmarks/0014.file_io/file_io.

Output 100000000x "Hello World\n"

Notice: I modified libstdc++'s std::filebuf's BUFSIZ to 1048576 due to BUFSIZ is too small (512 bytes) for MinGW-W64 or it performs horribly.

4. Binary Size Just use the benchmark in benchmarks/0014.file_io/file_io. Dude, you should avoid stream as plague tbh. It is not healthy.

5. Code Convert

Generate 100000000 🚄 emojis by using the program in benchmarks/0020.utf/fill_nc.cc

Benchmarks are in examples/0043.iconv Universal iconv. (UTF-8 to GB18030 as an example) iconv test:

UTF8->UTF16LE

Benchmarks are in examples/0022.utf

iconv test:

UTF8->UTF32LE

Benchmarks are in examples/0022.utf

iconv test:

The creation and development of this project were made possible thanks to the valuable contributions of various open-source projects. While the code was not copied directly from these projects, I used them as references and re-implemented them to suit the specific purposes of this library. In some cases, integration issues arose that required modifications to the original code. I am grateful to these projects and their developers for their commitment to making their code open and accessible to the wider community.