microsoft/STL

microsoft/STL

Description: MSVC's implementation of the C++ Standard Library.

Language: C++

License: NOASSERTION

Stars: 11076

Forks: 1624

Open issues: 564

Created: 2019-08-27T01:31:18Z

Pushed: 2026-06-10T08:23:35Z

Default branch: main

Fork: no

Archived: no

README:

Microsoft's C++ Standard Library

This is the official repository for Microsoft's implementation of the C++ Standard Library (also known as the STL), which ships as part of the MSVC toolset and the Visual Studio IDE.

• Our [Changelog][] tracks which updates to this repository appear in each VS release.
• Our [Status Chart][] displays our overall progress over time.
• Join our [Discord server][].
• [![CI Status Badge][STL-CI-badge]][STL-CI-link] (STL-CI build status)
• [![ASan CI Status Badge][STL-ASan-CI-badge]][STL-ASan-CI-link] (STL-ASan-CI build status)

What This Repo Is Useful For

If you're a programmer who just wants to use the STL, you don't need this repo. Simply install the Visual Studio IDE and select the "Desktop development with C++" workload.

If you want to participate in the STL's development, welcome! You can report issues, comment on pull requests, and learn about what we're working on. You can also submit pull requests to fix bugs or add features: see [CONTRIBUTING.md][] for more information.

Finally, you can take our code and use it in other apps and libraries (according to the terms of our license, like everything else).

GitHub Migration Status

We're in the process of moving all of our work on the STL to GitHub. Current status:

• Code: Done. Our source code is available under the Apache License v2.0 with LLVM Exception. (See

[LICENSE.txt][] and [NOTICE.txt][] for more information.)

• Build System: In progress. We're working on a CMake build system, which is currently capable of building one

flavor of the STL (native desktop). We need to extend this to build all of the flavors required for the MSVC toolset (e.g. /clr, /clr:pure, OneCore, Spectre). Until that's done, we're keeping our legacy build system around in the stl/msbuild subdirectory. (We're keeping those files in this repo, even though they're unusable outside of Microsoft, because they need to be updated whenever source files are added/renamed/deleted. We'll delete the legacy machinery as soon as possible.)

• Tests: In progress. We rely on three test suites: std, tr1, and [libcxx][]. We've partially ported std and tr1,

and fully ported libcxx to run under [lit][] using the various configurations/compilers we test internally.

• Continuous Integration: In progress. We've set up Azure Pipelines to validate changes to the repository.

Currently, it builds the STL for x64, x86, ARM64, and ARM64EC. Also, it strictly verifies that all of our files have been formatted with [clang-format][] and follow our other whitespace conventions.

• Contribution Guidelines: Coming soon. Working on the STL's code involves following many rules. We have codebase

conventions, Standard requirements, Microsoft-specific requirements, binary compatibility (ABI) requirements, and more. We're eager to begin accepting features and fixes from the community, but in addition to setting up a CI system, we need to write down all of the rules that are currently stored in our brains. (The ABI rules may be useful to other C++ libraries.)

• Issues: In progress. We're going to use GitHub issues to track all of the things that we need to work on. This

includes C++20 features, [LWG issues][], conformance bugs, performance improvements, and other todos. There are approximately 200 active bugs in the STL's Microsoft-internal database; we need to manually replicate all of them to GitHub issues. Currently, the [cxx20 tag][] and [LWG tag][] are done; every remaining work item is tracked by a GitHub issue. The [bug tag][] and [enhancement tag][] are being populated.

• Plans: In progress. We're writing up our [Roadmap][].

Goals

We're implementing the latest C++ Working Draft, currently [N5046][], which will eventually become the next C++ International Standard. The terms Working Draft (WD) and Working Paper (WP) are interchangeable; we often informally refer to these drafts as "the Standard" while being aware of the difference. (There are other relevant Standards; for example, supporting /std:c++14 and /std:c++17 involves understanding how the C++14 and C++17 Standards differ from the Working Paper, and we often need to refer to the C Standard Library and ECMAScript regular expression specifications.)

Our primary goals are conformance, performance, usability, and compatibility.

• Conformance: The Working Paper is a moving target; as features and LWG issue resolutions are added, we need to

implement them. That can involve a lot of work because the STL is required to behave in very specific ways and to handle users doing very unusual things.

• Performance: The STL needs to be extremely fast at runtime; speed is one of C++'s core strengths and most C++

programs use the STL extensively. As a result, we spend more time on optimization than most general-purpose libraries. (However, we're wary of changes that improve some scenarios at the expense of others, or changes that make code significantly more complicated and fragile. That is, there's a "complexity budget" that must be spent carefully.)

• Usability: This includes parts of the programming experience like compiler throughput, diagnostic messages, and

debugging checks. For example, we've extensively marked the STL with [[nodiscard]] attributes because this helps programmers avoid bugs.

• Compatibility: This includes binary compatibility and source compatibility. We're keeping VS 2026 binary-compatible

with VS 2015-2022, which restricts what we can change in VS 2026 updates. (We've found that significant changes are possible even though other changes are impossible, which we'll be documenting in our Contribution Guidelines soon.) While there are a few exceptions to this rule (e.g. if a feature is added to the Working Paper, we implement it, and then the feature is significantly changed before the International Standard is finalized, we reserve the right to break binary compatibility because /std:c++latest offers an experimental preview of such features), binary compatibility generally overrides all other considerations, even conformance. Source compatibility refers to being able to successfully recompile user code without changes. We consider source…