In my humble opinion I think dlib ^[1] has some of the most readable code around. Modern style, RAII, no pointers, religious use of contract programming, etc.

But I maybe biased as I run this particular open source project :)

I see that you've already decided that Boost is "less readable than [you'd] like", but Boost is quite possibly the best example of exactly the kind of source code you're looking for. The unfortunate fact is that in spite of all of its positive characteristics, C++ itself is less readable than you'd like.

The more time you spend reading Boost code, the more C++ you'll understand and the more readable it all becomes.

At the op's suggestion, here are some libraries I think are pretty good:

• smart_ptr - small, pretty self-contained, and idiomatic. Might be a good starting place.
• pool - more complicated than smart_ptr, but still fairly portable and idiomatic.
• filesystem - also sort of "medium" complexity, not terribly portable, but very useful and intuitive
• iostreams - large, complicated, many patterns, lots of platform-specific things
• asio - also large, complicated, and not portable.

There are many more to choose from.

One of the things that makes Boost good, and still readable, is that most of its libraries consistently factor out the platform/compiler-specific tweaks and leave the primary functionality as portable as possible. It's a really, really great thing for C++ devs to learn.

Note: when I say "portable" or "not portable" above, I'm not talking about the library as a whole, but rather the underlying implementation that a reader would be looking at. In other words, "not portable" means lots of implementation details that are particular to a platform. Boost libraries are amazingly portable in practice; I don't want to be misunderstood.

You could have a look at:

• dlib ^[1]
• Some Google C++ projects, like Protocol Buffers ^[2]
• Ogre3D ^[3]

Some projects NOT to learn from:

• QT ^[4] ("C-with-classes", not modern C++)
• wxWidgets ^[5] (Quite old, has its own string class).

Also I wouldn't recommend reading the Boost code if you are a C++ newbie, you will get buried in little details.

I've played around some with Google Test ^[1] (Google's C++ unit testing framework) and have been impressed with its clean design and clarity of code. It's also interesting to me how Google Test's adherence to the Google C++ Style Guide ^[2] enhances its readability (even though I don't always agree with the Google C++ Style Guide).

I would expect other notable C++ projects from Google, such as Chromium ^[3] (the codebase for Google Chrome) and Protocol Buffers ^[4], to be similarly high quality.

I'm surprised nobody mentioned Loki ^[1]

Another well-written C++ project is the Monotone version control system ^[1].

I would say: if the code is beautiful, easy to read, modern, portable and uses latest goodies of C++, then probably you are reading textbook...

Unfortunately most of modern code is not so easy to read and far from being beautiful... Because real life is quite hard.

Examples of greatest modern software libraries that extremely useful and good designed Boost and C++.

• Boost - includes lots of ifdefs for each broken compiler and to work well on many broken OS platforms.
• Boost - some libraries push template meta-programming to limit in order to get as much flexibility as possible but readability suffers!
• Qt - very well designed modern, very useful library (even some people think that if library does not push to limit all templates stuff it is not true C++) but... it requires to run on even very old and odd compilers... So you will find many oddities like not using dynamic_cast or other stuff. But it is great, well debugged high quality software.

Bottom line, programming is hard. Take a look on this code ^[1] I had written. It is code of cache system with invalidation, triggers, LRU and timeout support, that can be shared between forked processes and normal threads... But it is damn hard to read and understand. But is very valuable piece of software to me that required lots of writing.

(And it is uses STL, smart pointer, allocators, RAII and many other goodies)

P.S.: I do not recommend to learn from my code ;-)

QT ^[1] is very well documented and has a nice and elegant design.

http://www.virtualbox.org - mostly because it's a complete,complex and large application(s) - and not "just" a library.

I'd learned a lot from the source code of http://code.google.com/p/protobuf/ as well.

I think one of the projects that i've encountered that definitely deserve praise by the cleanliness of the design and source is LLVM ^[1]. This library is both very complex, but very modularized, so you probably won't need to learn much about the library that is tangential or unrelated to what you want to achieve. The interesting thing about llvm is that they don't believe that there is a tradeoff between good design and good performance targeting. For example, there are quite a few scenario focused containers implementations ^[2] that provide optimizations in specific circumstances.

The source and documentation is a pleasure to read, and they take regression testing very seriously.

If someone would like to learn how to design a complex c++ codebase that is mantainable and well designed, is encouraged to study LLVM

I think ACE ^[1] is a good example of a mature open-source multi-platform C++ library with a lot of available documentation ^[2]. A lot of the documentation is in the form of academic papers, so you learn a lot about the underlying algorithms, design patterns, and tradeoffs.

However, note that it originated some time ago, and suffers from some ugliness in order to be compatible with all the C++ compilers it has ever supported. So it may not fit your desire for "modern" C++ code.

I've only been out of school for about half a year so this may not mean much, but the Hotspot JVM is the best documented program I have ever worked with (of any language). This includes almost all of the toy programs from university courses with the exception of the OS161 operating system.

Speaking of which, that's another example of great, (very)well-documented C++ code. But it's all C, so it's far from modern.

Hotspot has good documentation throughout, and at every level of abstraction, which is rare. Most of the time programs settle for good commenting, which explains the local details of how code works, but no more. With hotspot, there are plenty of resources describing how the whole thing works, most files have comments saying what goes on in there. So do classes and methods. When certain things are done for optimization purposes, this is noted.

How about OpenSceneGraph? A great rendering engine with very clean structure.