GitHub C++ Trending

The latest build: 2024-06-20Source of data: GitHubTrendingRSS

Bear is a tool that generates a compilation database for clang tooling.

Packaging statusGitHub releaseGitHub Release DateContinuous IntegrationContributorsGitter

·· Build EAR

Bear is a tool that generates a compilation database for clang tooling.

The JSON compilation database is used in the clang project to provide information on how a single compilation unit is processed. With this, it is easy to re-run the compilation with alternate programs.

Some build system natively supports the generation of JSON compilation database. For projects which does not use such build tool, Bear generates the JSON file during the build process.

How to install

Bear is packaged for many distributions. Check out your package manager. Or build it from source.

How to use

After installation the usage is like this:

bear -- <your-build-command>

The output file called compile_commands.json is saved in the current directory.

For more options you can check the man page or pass --help parameter. Note that if you want to pass parameter to Bear, pass those before the -- sign, everything after that will be the build command.

Please be aware that some package manager still ship our old 2.4.x release. In that case please omit the extra -- sign or consult your local documentation.

For more, read the man pages or wiki of the project, which talks about limitations, known issues and platform specific usage.

Problem reports

Before you open a new problem report, please look at the wiki if your problem is a known one with documented workaround. It's also helpful to look at older (maybe closed) issues before you open a new one.

If you decided to report a problem, try to give as much context as it would help me to reproduce the error you see. If you just have a question about the usage, please don't be shy, ask your question in an issue or in chat.

If you found a bug, but also found a fix for it, please share it with me and open a pull request.

Please follow the contribution guide when you do these.

Thanks to JetBrains for donating product licenses to help develop Bear

Log file navigator

BuildDocsCoverage Statuslnav

Discord Logo

This is the source repository for lnav, visit https://lnav.org for a high level overview.

LNAV -- The Logfile Navigator

The Logfile Navigator is a log file viewer for the terminal. Given a set of files/directories, lnav will:

  • decompress as needed;
  • detect their format;
  • merge the files together by time into a single view;
  • tail the files, follow renames, find new files in directories;
  • build an index of errors and warnings;
  • pretty-print JSON-lines.

Then, in the lnav TUI, you can:


The following screenshot shows a mix of syslog and web access log files. Failed requests are shown in red. Identifiers, like IP address and PIDs are semantically highlighted.


Why not just use tail/grep/less?

The standard Unix utilities are great for processing raw text lines, however, they do not understand log messages. Tail can watch multiple files at a time, but it won't display messages in order by time and you can't scroll backwards. Grep will only find matching lines, but won't return a full multi-line log message. Less can only display a single file at a time. Also, none of these basic tools handle compressed files.

Try online before installing

You can SSH into a demo node to play with lnav before installing.

The "playground" account starts lnav with a couple of log files as an example:

$ ssh [email protected]

The "tutorial 1" account is an interactive tutorial that can teach you the basics of operation:

$ ssh [email protected]


Download a statically-linked binary for Linux/MacOS from the release page

Brew on MacOS

$ brew install lnav


Simply point lnav at the files or directories you want to monitor, it will figure out the rest:

$ lnav /path/to/file1 /path/to/dir ...

The lnav TUI will pop up right away and begin indexing the files. Progress is displayed in the "Files" panel at the bottom. Once the indexing has finished, the LOG view will display the log messages that were recognized[^1]. You can then use the usual hotkeys to move around the view (arrow keys or j/k/h/l to move down/up/left/right).

See the Usage section of the online documentation for more information.

[^1]: Files that do not contain log messages can be seen in the TEXT view (reachable by pressing t).

Usage with systemd-journald

On systems running systemd-journald, you can use lnav as the pager:

$ journalctl | lnav

or in follow mode:

$ journalctl -f | lnav

Since journalctl's default output format omits the year, if you are viewing logs which span multiple years you will need to change the output format to include the year, otherwise lnav gets confused:

$ journalctl -o short-iso | lnav

It is also possible to use journalctl's json output format and lnav will make use of additional fields such as PRIORITY and _SYSTEMD_UNIT:

$ journalctl -o json | lnav

In case some MESSAGE fields contain special characters such as ANSI color codes which are considered as unprintable by journalctl, specifying journalctl's -a option might be preferable in order to output those messages still in a non-binary representation:

$ journalctl -a -o json | lnav

If using systemd v236 or newer, the output fields can be limited to the ones actually recognized by lnav for increased efficiency:

$ journalctl -o json --output-fields=MESSAGE,PRIORITY,_PID,SYSLOG_IDENTIFIER,_SYSTEMD_UNIT | lnav

If your system has been running for a long time, for increased efficiency you may want to limit the number of log lines fed into lnav, e.g. via journalctl's -n or --since=... options.

In case of a persistent journal, you may want to limit the number of log lines fed into lnav via journalctl's -b option.


Please file issues on this repository or use the discussions section. The following alternatives are also available:



Building From Source


The following software packages are required to build lnav:

  • gcc/clang - A C++14-compatible compiler.
  • libpcre2 - The Perl Compatible Regular Expression v2 (PCRE2) library.
  • sqlite - The SQLite database engine. Version 3.9.0 or higher is required.
  • ncurses - The ncurses text UI library.
  • readline - The readline line editing library.
  • zlib - The zlib compression library.
  • bz2 - The bzip2 compression library.
  • libcurl - The cURL library for downloading files from URLs. Version 7.23.0 or higher is required.
  • libarchive - The libarchive library for opening archive files, like zip/tgz.
  • wireshark - The 'tshark' program is used to interpret pcap files.
  • cargo/rust - The Rust language is used to build the PRQL compiler.


Lnav follows the usual GNU style for configuring and installing software:

Run ./autogen.sh if compiling from a cloned repository.

$ ./configure$ make$ sudo make install

See Also

Angle-grinder is a tool to slice and dice log files on the command-line. If you're familiar with the SumoLogic query language, you might find this tool more comfortable to work with.

A C++ header-only HTTP/HTTPS server and client library


A C++11 single-file header-only cross platform HTTP/HTTPS library.

It's extremely easy to setup. Just include the httplib.h file in your code!

[!IMPORTANT] This library uses 'blocking' socket I/O. If you are looking for a library with 'non-blocking' socket I/O, this is not the one that you want.

Simple examples

Server (Multi-threaded)

#define CPPHTTPLIB_OPENSSL_SUPPORT#include "path/to/httplib.h"// HTTPhttplib::Server svr;// HTTPShttplib::SSLServer svr;svr.Get("/hi", [](const httplib::Request &, httplib::Response &res) { res.set_content("Hello World!", "text/plain");});svr.listen("", 8080);


#define CPPHTTPLIB_OPENSSL_SUPPORT#include "path/to/httplib.h"// HTTPhttplib::Client cli("http://cpp-httplib-server.yhirose.repl.co");// HTTPShttplib::Client cli("https://cpp-httplib-server.yhirose.repl.co");auto res = cli.Get("/hi");res->status;res->body;

SSL Support

SSL support is available with CPPHTTPLIB_OPENSSL_SUPPORT. libssl and libcrypto should be linked.

[!NOTE] cpp-httplib currently supports only version 3.0 or later. Please see this page to get more information.

[!TIP] For macOS: cpp-httplib now can use system certs with CPPHTTPLIB_USE_CERTS_FROM_MACOSX_KEYCHAIN. CoreFoundation and Security should be linked with -framework.

#define CPPHTTPLIB_OPENSSL_SUPPORT#include "path/to/httplib.h"// Serverhttplib::SSLServer svr("./cert.pem", "./key.pem");// Clienthttplib::Client cli("https://localhost:1234"); // scheme + hosthttplib::SSLClient cli("localhost:1234"); // hosthttplib::SSLClient cli("localhost", 1234); // host, port// Use your CA bundlecli.set_ca_cert_path("./ca-bundle.crt");// Disable cert verificationcli.enable_server_certificate_verification(false);

[!NOTE] When using SSL, it seems impossible to avoid SIGPIPE in all cases, since on some operating systems, SIGPIPE can only be suppressed on a per-message basis, but there is no way to make the OpenSSL library do so for its internal communications. If your program needs to avoid being terminated on SIGPIPE, the only fully general way might be to set up a signal handler for SIGPIPE to handle or ignore it yourself.


#include <httplib.h>int main(void){ using namespace httplib; Server svr; svr.Get("/hi", [](const Request& req, Response& res) { res.set_content("Hello World!", "text/plain"); }); // Match the request path against a regular expression // and extract its captures svr.Get(R"(/numbers/(\d+))", [&](const Request& req, Response& res) { auto numbers = req.matches[1]; res.set_content(numbers, "text/plain"); }); // Capture the second segment of the request path as "id" path param svr.Get("/users/:id", [&](const Request& req, Response& res) { auto user_id = req.path_params.at("id"); res.set_content(user_id, "text/plain"); }); // Extract values from HTTP headers and URL query params svr.Get("/body-header-param", [](const Request& req, Response& res) { if (req.has_header("Content-Length")) { auto val = req.get_header_value("Content-Length"); } if (req.has_param("key")) { auto val = req.get_param_value("key"); } res.set_content(req.body, "text/plain"); }); svr.Get("/stop", [&](const Request& req, Response& res) { svr.stop(); }); svr.listen("localhost", 1234);}

Post, Put, Delete and Options methods are also supported.

Bind a socket to multiple interfaces and any available port

int port = svr.bind_to_any_port("");svr.listen_after_bind();

Static File Server

// Mount / to ./www directoryauto ret = svr.set_mount_point("/", "./www");if (!ret) { // The specified base directory doesn't exist...}// Mount /public to ./www directoryret = svr.set_mount_point("/public", "./www");// Mount /public to ./www1 and ./www2 directoriesret = svr.set_mount_point("/public", "./www1"); // 1st order to searchret = svr.set_mount_point("/public", "./www2"); // 2nd order to search// Remove mount /ret = svr.remove_mount_point("/");// Remove mount /publicret = svr.remove_mount_point("/public");
// User defined file extension and MIME type mappingssvr.set_file_extension_and_mimetype_mapping("cc", "text/x-c");svr.set_file_extension_and_mimetype_mapping("cpp", "text/x-c");svr.set_file_extension_and_mimetype_mapping("hh", "text/x-h");

The followings are built-in mappings:

ExtensionMIME TypeExtensionMIME Type
html, htmtext/htmlttffont/ttf
svgimage/svg+xmlmjs, jsapplication/javascript
tiffimage/tiffxhtml, xhtapplication/xhtml+xml
jpeg, jpgimage/jpegxsltapplication/xslt+xml

[!WARNING] These static file server methods are not thread-safe.

File request handler

// The handler is called right before the response is sent to a clientsvr.set_file_request_handler([](const Request &req, Response &res) { ...});


svr.set_logger([](const auto& req, const auto& res) { your_logger(req, res);});

Error handler

svr.set_error_handler([](const auto& req, auto& res) { auto fmt = "<p>Error Status: <span style='color:red;'>%d</span></p>"; char buf[BUFSIZ]; snprintf(buf, sizeof(buf), fmt, res.status); res.set_content(buf, "text/html");});

Exception handler

The exception handler gets called if a user routing handler throws an error.

svr.set_exception_handler([](const auto& req, auto& res, std::exception_ptr ep) { auto fmt = "<h1>Error 500</h1><p>%s</p>"; char buf[BUFSIZ]; try { std::rethrow_exception(ep); } catch (std::exception &e) { snprintf(buf, sizeof(buf), fmt, e.what()); } catch (...) { // See the following NOTE snprintf(buf, sizeof(buf), fmt, "Unknown Exception"); } res.set_content(buf, "text/html"); res.status = StatusCode::InternalServerError_500;});

[!CAUTION] if you don't provide the catch (...) block for a rethrown exception pointer, an uncaught exception will end up causing the server crash. Be careful!

Pre routing handler

svr.set_pre_routing_handler([](const auto& req, auto& res) { if (req.path == "/hello") { res.set_content("world", "text/html"); return Server::HandlerResponse::Handled; } return Server::HandlerResponse::Unhandled;});

Post routing handler

svr.set_post_routing_handler([](const auto& req, auto& res) { res.set_header("ADDITIONAL_HEADER", "value");});

'multipart/form-data' POST data

svr.Post("/multipart", [&](const auto& req, auto& res) { auto size = req.files.size(); auto ret = req.has_file("name1"); const auto& file = req.get_file_value("name1"); // file.filename; // file.content_type; // file.content;});

Receive content with a content receiver

svr.Post("/content_receiver", [&](const Request &req, Response &res, const ContentReader &content_reader) { if (req.is_multipart_form_data()) { // NOTE: `content_reader` is blocking until every form data field is read MultipartFormDataItems files; content_reader( [&](const MultipartFormData &file) { files.push_back(file); return true; }, [&](const char *data, size_t data_length) { files.back().content.append(data, data_length); return true; }); } else { std::string body; content_reader([&](const char *data, size_t data_length) { body.append(data, data_length); return true; }); } });

Send content with the content provider

const size_t DATA_CHUNK_SIZE = 4;svr.Get("/stream", [&](const Request &req, Response &res) { auto data = new std::string("abcdefg"); res.set_content_provider( data->size(), // Content length "text/plain", // Content type [&, data](size_t offset, size_t length, DataSink &sink) { const auto &d = *data; sink.write(&d[offset], std::min(length, DATA_CHUNK_SIZE)); return true; // return 'false' if you want to cancel the process. }, [data](bool success) { delete data; });});

Without content length:

svr.Get("/stream", [&](const Request &req, Response &res) { res.set_content_provider( "text/plain", // Content type [&](size_t offset, DataSink &sink) { if (/* there is still data */) { std::vector<char> data; // prepare data... sink.write(data.data(), data.size()); } else { sink.done(); // No more data } return true; // return 'false' if you want to cancel the process. });});

Chunked transfer encoding

svr.Get("/chunked", [&](const Request& req, Response& res) { res.set_chunked_content_provider( "text/plain", [](size_t offset, DataSink &sink) { sink.write("123", 3); sink.write("345", 3); sink.write("789", 3); sink.done(); // No more data return true; // return 'false' if you want to cancel the process. } );});

With trailer:

svr.Get("/chunked", [&](const Request& req, Response& res) { res.set_header("Trailer", "Dummy1, Dummy2"); res.set_chunked_content_provider( "text/plain", [](size_t offset, DataSink &sink) { sink.write("123", 3); sink.write("345", 3); sink.write("789", 3); sink.done_with_trailer({ {"Dummy1", "DummyVal1"}, {"Dummy2", "DummyVal2"} }); return true; } );});

'Expect: 100-continue' handler

By default, the server sends a 100 Continue response for an Expect: 100-continue header.

// Send a '417 Expectation Failed' response.svr.set_expect_100_continue_handler([](const Request &req, Response &res) { return StatusCode::ExpectationFailed_417;});
// Send a final status without reading the message body.svr.set_expect_100_continue_handler([](const Request &req, Response &res) { return res.status = StatusCode::Unauthorized_401;});

Keep-Alive connection

svr.set_keep_alive_max_count(2); // Default is 5svr.set_keep_alive_timeout(10); // Default is 5


svr.set_read_timeout(5, 0); // 5 secondssvr.set_write_timeout(5, 0); // 5 secondssvr.set_idle_interval(0, 100000); // 100 milliseconds

Set maximum payload length for reading a request body

svr.set_payload_max_length(1024 * 1024 * 512); // 512MB

[!NOTE] When the request body content type is 'www-form-urlencoded', the actual payload length shouldn't exceed CPPHTTPLIB_FORM_URL_ENCODED_PAYLOAD_MAX_LENGTH.

Server-Sent Events

Please see Server example and Client example.

Default thread pool support

ThreadPool is used as a default task queue, and the default thread count is 8, or std::hardware_concurrency(). You can change it with CPPHTTPLIB_THREAD_POOL_COUNT.

If you want to set the thread count at runtime, there is no convenient way... But here is how.

svr.new_task_queue = [] { return new ThreadPool(12); };

You can also provide an optional parameter to limit the maximum number of pending requests, i.e. requests accept()ed by the listener but still waiting to be serviced by worker threads.

svr.new_task_queue = [] { return new ThreadPool(/*num_threads=*/12, /*max_queued_requests=*/18); };

Default limit is 0 (unlimited). Once the limit is reached, the listener will shutdown the client connection.

Override the default thread pool with yours

You can supply your own thread pool implementation according to your need.

class YourThreadPoolTaskQueue : public TaskQueue {public: YourThreadPoolTaskQueue(size_t n) { pool_.start_with_thread_count(n); } virtual bool enqueue(std::function<void()> fn) override { /* Return true if the task was actually enqueued, or false * if the caller must drop the corresponding connection. */ return pool_.enqueue(fn); } virtual void shutdown() override { pool_.shutdown_gracefully(); }private: YourThreadPool pool_;};svr.new_task_queue = [] { return new YourThreadPoolTaskQueue(12);};


#include <httplib.h>#include <iostream>int main(void){ httplib::Client cli("localhost", 1234); if (auto res = cli.Get("/hi")) { if (res->status == StatusCode::OK_200) { std::cout << res->body << std::endl; } } else { auto err = res.error(); std::cout << "HTTP error: " << httplib::to_string(err) << std::endl; }}

[!TIP] Constructor with scheme-host-port string is now supported!

httplib::Client cli("localhost");httplib::Client cli("localhost:8080");httplib::Client cli("http://localhost");httplib::Client cli("http://localhost:8080");httplib::Client cli("https://localhost");httplib::SSLClient cli("localhost");

Error code

Here is the list of errors from Result::error().

enum Error { Success = 0, Unknown, Connection, BindIPAddress, Read, Write, ExceedRedirectCount, Canceled, SSLConnection, SSLLoadingCerts, SSLServerVerification, UnsupportedMultipartBoundaryChars, Compression, ConnectionTimeout,};

GET with HTTP headers

httplib::Headers headers = { { "Accept-Encoding", "gzip, deflate" }};auto res = cli.Get("/hi", headers);


auto res = cli.Get("/hi", {{"Accept-Encoding", "gzip, deflate"}});


cli.set_default_headers({ { "Accept-Encoding", "gzip, deflate" }});auto res = cli.Get("/hi");


res = cli.Post("/post", "text", "text/plain");res = cli.Post("/person", "name=john1&note=coder", "application/x-www-form-urlencoded");

POST with parameters

httplib::Params params;params.emplace("name", "john");params.emplace("note", "coder");auto res = cli.Post("/post", params);


httplib::Params params{ { "name", "john" }, { "note", "coder" }};auto res = cli.Post("/post", params);

POST with Multipart Form Data

httplib::MultipartFormDataItems items = { { "text1", "text default", "", "" }, { "text2", "ab", "", "" }, { "file1", "h\ne\n\nl\nl\no\n", "hello.txt", "text/plain" }, { "file2", "{\n \"world\", true\n}\n", "world.json", "application/json" }, { "file3", "", "", "application/octet-stream" },};auto res = cli.Post("/multipart", items);


res = cli.Put("/resource/foo", "text", "text/plain");


res = cli.Delete("/resource/foo");


res = cli.Options("*");res = cli.Options("/resource/foo");


cli.set_connection_timeout(0, 300000); // 300 millisecondscli.set_read_timeout(5, 0); // 5 secondscli.set_write_timeout(5, 0); // 5 seconds

Receive content with a content receiver

std::string body;auto res = cli.Get("/large-data", [&](const char *data, size_t data_length) { body.append(data, data_length); return true; });
std::string body;auto res = cli.Get( "/stream", Headers(), [&](const Response &response) { EXPECT_EQ(StatusCode::OK_200, response.status); return true; // return 'false' if you want to cancel the request. }, [&](const char *data, size_t data_length) { body.append(data, data_length); return true; // return 'false' if you want to cancel the request. });

Send content with a content provider

std::string body = ...;auto res = cli.Post( "/stream", body.size(), [](size_t offset, size_t length, DataSink &sink) { sink.write(body.data() + offset, length); return true; // return 'false' if you want to cancel the request. }, "text/plain");

Chunked transfer encoding

auto res = cli.Post( "/stream", [](size_t offset, DataSink &sink) { sink.os << "chunked data 1"; sink.os << "chunked data 2"; sink.os << "chunked data 3"; sink.done(); return true; // return 'false' if you want to cancel the request. }, "text/plain");

With Progress Callback

httplib::Client cli(url, port);// prints: 0 / 000 bytes => 50% completeauto res = cli.Get("/", [](uint64_t len, uint64_t total) { printf("%lld / %lld bytes => %d%% complete\n", len, total, (int)(len*100/total)); return true; // return 'false' if you want to cancel the request.});



// Basic Authenticationcli.set_basic_auth("user", "pass");// Digest Authenticationcli.set_digest_auth("user", "pass");// Bearer Token Authenticationcli.set_bearer_token_auth("token");

[!NOTE] OpenSSL is required for Digest Authentication.

Proxy server support

cli.set_proxy("host", port);// Basic Authenticationcli.set_proxy_basic_auth("user", "pass");// Digest Authenticationcli.set_proxy_digest_auth("user", "pass");// Bearer Token Authenticationcli.set_proxy_bearer_token_auth("pass");

[!NOTE] OpenSSL is required for Digest Authentication.


httplib::Client cli("httpbin.org");auto res = cli.Get("/range/32", { httplib::make_range_header({{1, 10}}) // 'Range: bytes=1-10'});// res->status should be 206.// res->body should be "bcdefghijk".
httplib::make_range_header({{1, 10}, {20, -1}}) // 'Range: bytes=1-10, 20-'httplib::make_range_header({{100, 199}, {500, 599}}) // 'Range: bytes=100-199, 500-599'httplib::make_range_header({{0, 0}, {-1, 1}}) // 'Range: bytes=0-0, -1'

Keep-Alive connection

httplib::Client cli("localhost", 1234);cli.Get("/hello"); // with "Connection: close"cli.set_keep_alive(true);cli.Get("/world");cli.set_keep_alive(false);cli.Get("/last-request"); // with "Connection: close"


httplib::Client cli("yahoo.com");auto res = cli.Get("/");res->status; // 301cli.set_follow_location(true);res = cli.Get("/");res->status; // 200

Use a specific network interface

[!NOTE] This feature is not available on Windows, yet.

cli.set_interface("eth0"); // Interface name, IP address or host name


The server can apply compression to the following MIME type contents:

  • all text types except text/event-stream
  • image/svg+xml
  • application/javascript
  • application/json
  • application/xml
  • application/xhtml+xml

Zlib Support

'gzip' compression is available with CPPHTTPLIB_ZLIB_SUPPORT. libz should be linked.

Brotli Support

Brotli compression is available with CPPHTTPLIB_BROTLI_SUPPORT. Necessary libraries should be linked. Please see https://github.com/google/brotli for more detail.

Compress request body on client

cli.set_compress(true);res = cli.Post("/resource/foo", "...", "text/plain");

Compress response body on client

cli.set_decompress(false);res = cli.Get("/resource/foo", {{"Accept-Encoding", "gzip, deflate, br"}});res->body; // Compressed data

Use poll instead of select

select system call is used as default since it's more widely supported. If you want to let cpp-httplib use poll instead, you can do so with CPPHTTPLIB_USE_POLL.

Split httplib.h into .h and .cc

$ ./split.py -husage: split.py [-h] [-e EXTENSION] [-o OUT]This script splits httplib.h into .h and .cc parts.optional arguments: -h, --help show this help message and exit -e EXTENSION, --extension EXTENSION extension of the implementation file (default: cc) -o OUT, --out OUT where to write the files (default: out)$ ./split.pyWrote out/httplib.h and out/httplib.cc



g++ 4.8 and below cannot build this library since <regex> in the versions are broken.


Include httplib.h before Windows.h or include Windows.h by defining WIN32_LEAN_AND_MEAN beforehand.

#include <httplib.h>#include <Windows.h>
#define WIN32_LEAN_AND_MEAN#include <Windows.h>#include <httplib.h>

[!NOTE] cpp-httplib officially supports only the latest Visual Studio. It might work with former versions of Visual Studio, but I can no longer verify it. Pull requests are always welcome for the older versions of Visual Studio unless they break the C++11 conformance.

[!NOTE] Windows 8 or lower, Visual Studio 2013 or lower, and Cygwin and MSYS2 including MinGW are neither supported nor tested.


MIT license (© 2024 Yuji Hirose)

Special Thanks To

These folks made great contributions to polish this library to totally another level from a simple toy!