GSoC/GCI Archive
Google Summer of Code 2015

Boost C++ Libraries

License: Boost Software License (BSL1.0)

Web Page:

Mailing List:

Boost provides free peer-reviewed portable C++ source libraries.

We emphasize libraries that work well with the C++ Standard Library. Boost libraries are intended to be widely useful, and usable across a broad spectrum of applications. The Boost license encourages both commercial and non-commercial use.

We aim to establish "existing practice" and provide reference implementations so that Boost libraries are suitable for eventual standardization. Ten Boost libraries are included in the C++ Standards Committee's Library Technical Report (TR1) and in the new C++11 Standard. C++11 also includes several more Boost libraries in addition to those from TR1. More Boost libraries are proposed for standardization in C++17.

Since 2006 an intimate week long annual conference related to Boost called C++ Now has been held in Aspen, Colorado each May. Boost has been a participant in the annual Google Summer of Code since 2007.


  • Boost Document Library Development To unify APIs of different Office suits and provide a library that is capable of doing simple tasks with office documents (creation, pdf exporting, file format changes, data extraction and cells manipulations). The library aims to simplify the Office API usage to such an extent that casual users can make their own applications using it. Currently, the Office API’s are not that intuitive and easy to use, and this abstraction layer would provide easier access and thus higher productivity.
  • Boost uBLAS EigenSolver In this project, I propose to extend the usability of the Boost uBLAS Linear Algebra Library with an eigensolver module for real, dense matrices. Apart from Eigen Decomposition, modules will be provided for SVD which is one of the most commonly used operations in data mining, machine learning and other scientific applications. The algorithms implemented will closely follow other commercial libraries like Eigen and Armadillo.
  • Boost.Fixed-Point In this project, we will provide an implementation of a fixed-point library based on The core work involves developing a series of templates and template specializations that embody the fixed-point numbers in various precision ranges.
  • Enhanced vector and deque containers I propose to write a full-fledged and enhanced C++11 versions of `std::vector` and `std::deque` with extra functionality that gives the programmer more control over buffers, segments and iteration. In case of devector, the main idea would be to allow cheap `push_front`, `pop_front`, `push_back` and `pop_back` operations. The deque (or segmented_devector) should be similar to std::queue, but with a dynamically specified segment size, taking the low-latency RDMA usecase into account.
  • Improved compile-time associative data structures for Hana The goal of this project is to improve the compile-time associative data structures present in the Hana C++14 metaprogramming library. I aim to provide a richer interface than what is currently available and also to improve the compile-time performance of those data structures, while keeping the runtime performance on-par with non-naive hand-written code.
  • Improving Boost.Compute Improving performance of the core Boost.Compute algorithms by choosing the best way to perform computations based not only on the size of problem, but also on used device and its hardware capabilities. Implementing reduction by key algorithm and support for using custom function in inclusive and exclusive prefix sum operations.
  • Safe Float (boost::safe_numerics<float>) Arithmetic operations in C++ are NOT guaranteed to yield a correct mathematical result. For instance, the overflow an addition operation may produce an infinite value. This project proposes implementing a drop-in replacement for float and double which guarantee that, when used in expressions in a C++ program, no incorrect arithmetic results will be produced without the developer awareness. The project intents to detect some issues at compile time, but some require to be detected at runtime.