Version History



  • A new method incoming_http_msg_limits added to restinio::server_settings_t. This method allows to set up limits for maximum length of various parts of an incoming HTTP message (like URL, HTTP-field’s name and value).
  • A possibility to limit the number of parallel connection has been added. See Limiting the number of parallel connections for more details.
  • A support for SObjectizer 5.6/5.7 has been added. Now RESTinio can be user either with SObjectizer 5.5 and SObjectizer 5.6/5.7. The version of SObjectizer is detected automatically. But if a user wants to use SObjectizer 5.6/5.7 he/she should set C++ standard to C++17 manually.


  • Conversion functions passed to restinio::easy_parser::convert can now return expected_t<T, error_reason_t> as well as just T. Returning expected_t<T, error_reason_t> allows to report conversion errors without throwing an exception.
  • A new overload for restinio::server_settings_t::address() method. The new overload accepts an instance of asio::ip::address.
  • A new optional hook added. This hook is called just after a succesful return from bind() for server’s acceptor. A reference to asio::ip::tcp::acceptor is passed to that hook. This new hook can be used for application-specific tuning of bound acceptor or to gathering some information about the acceptor.


  • A TLS-context object can be passed to server_settings_t as a shared pointer. This makes it possible to use one TLS-context by several instances of RESTinio server, or TLS-context can be shared between a RESTinio server and other parts of an application.


  • Support for Asio 1.17. Version 0.6.9 can be used with Asio 1.12, 1.14, 1.16 and 1.17.
  • Support for incoming requests with chunked encoding. Previous versions of RESTinio didn’t support such requests, an HTTP 501 error was returned. Since v.0.6.9 RESTinio accepts such requests and glues all chunks together into one body. Information about an individual chunk is preserved and is available via request_t::chunked_input_info.
  • A new way of handling CMake’s RESTINIO_ALLOW_SOBJECTIZER=OFF and introduction of RESTINIO_USE_EXTERNAL_SOBJECTIZER option.
  • New methods for http_header_fields_t class: remove_all_of and add_field;
  • New helpers for parsing the following HTTP-fields: Connection, Host, Transfer-Encoding;
  • New tools for easy_parser and HTTP-field parsers: expected_token_p, expected_caseless_token_p, symbol_from_range_p, caseless_exact, caseless_exact_p.


  • New helpers for extraction of parameters for Bearer authentification.


  • New run_async helper function. See details: run_async function.
  • New helpers for working with HTTP-fields like Authorization and Proxy-Authorization and extraction of parameters for Basic authentification. See details: Authorization helpers.



  • Set of symbols supported by restinio::parse_query_traits::javascript_compatible is extended (#76).
  • Addition of restinio::parse_query_traits::x_www_form_urlencoded, restinio::parse_query_traits::relaxed trais.
  • Introduction of try_parse_query. See try_parse_query function template for more details. There is also a new example try_parse_query_string.
  • Some functions that works with query-string and URI (like parse_query, try_parse_query) now do basic control of validity of UTF-8 sequences represented as percent-encoded characters.
  • New RESTINIO_USE_EXTERNAL_HTTP_PARSER option for CMake-based builds.


  • Several fixes, including very important one for (#72).
  • Parser for User-Agent HTTP-field.


  • Support for Asio 1.16 from Boost-1.72 (PR#67).
  • Fix for an unhandled exception during accepting a new connection (#68).
  • Support for fmt::basic_memory_buffer<char,1> in restinio::writable_item_t (#66). NOTE. Because of that addition RESTinio v.0.6.3 requires fmt-6.1.0 or newer.


  • Fix the behavior of the express router for the case when some symbols from unreserved character set are percent-encoded in path part of a URI. For example, when path is /%7euser instead of /~user.
  • Parsers for Accept-Charset, Accept-Encoding, Accept-Language and Range HTTP-fields.
  • Update externals: fmt 6.1.1, catch2 2.11.0.



  • API for connection state listeners changed. See Connection state listener for more details.
  • Connection state listener has access to TLS-related params for TLS-connections.
  • Some methods/functions now use [[nodiscard]] if it supported by C++ compiler.
  • Update externals: Asio 1.14.0 (Asio 1.12 is also supported), optional-lite 3.2.0, variant-lite 1.2.2, fmt 6.0.0 (fmt 5.3.0 is also supported).



  • An ability to use customized versions of http_parser library.
  • Type http_method_t removed, new type http_method_id_t added instead.


  • Update externals: Catch2 (2.7.1), http_parser (2.9.2).
  • Interface of http_header_fields_t class updated.
  • Fix: usage of CreateFileA on Windows instead of CreateFile.
  • Fix: sendfile operation on Windows closes the file twice.
  • Fix: tracking beacon in URL wasn’t handled properly.
  • Fix: sendfile operation on Windows opens a file in exclusive mode.
  • Semicolon is now supported as parameters separator in URI.
  • Support for “web beacon” and query_string_params_t::tag() method.
  • Function parse_query is a template now, special trait types restinio::parse_query_traits::restinio_defaults and restinio::parse_query_traits::javascript_compatible. (including

  • Update externals: asio (1.12.2), Catch2 (2.5.0), SObjectizer (5.5.24), fmtlib (5.3.0), http_parser (2.9.0).
  • Use Clara for argument parsing.
  • Fix: string_view and express router under VC++ and C++17.
  • Fix: race condition in notificators unit-test.
  • Fix: headers order for msvc.
  • Fix: library version in cmake file.
  • Fix: make restinio::websocket::basic::activate() function inline.
  • Make restinio::websocket::basic::activate() function inline.
  • Introduce enum restinio::websocket::basic::final_frame_flag_t to be used as a flag for ws-frames, that is more self explaining than bool.
  • New method remote_endpoint for requests and WS-handles.
  • Updates for async_handling_with_sobjectizer and websocket_detailed examples.


  • Add notificators for tracking status of written response data (see Notificators).
  • Add trace messages for response status line.
  • Improve response builders interfaces with rvalue qualified versions of setters.
  • Add support for arbitrary datasizeable types as buffers (see Types with datasizeable interface).


  • Add support for header fields in Provisional Message Header Field Names (from here).
  • Introduce safer interface for http_header_field_t using getters/setters. This involves a little incompatibility with prior versions if previously data members were accessed directly because now they a private.
  • Add base_response_builder_t::append_header( http_header_field_t http_header_field ) header field setter.
  • Enhance sendfile_t with file meta information (see File meta).
  • Add restinio::make_date_field_value() functions to format Date header fields (e.g. Fri, 15 Jun 2018 13:58:18 GMT).
  • Introduce restinio::http_status_line_t and a bunch of accompanying stuff, so now a standard response code and reason phrase can be set easily (see Status line).
  • Switch to fmtlib 5.1.0.


  • Switch to fmtlib 5.0.0.
  • Error description for absent key in a key-value container changed.
  • Make restinio::request_t streamable to std::ostream.



  • Add facilities for working with files. See details: File support (sendfile).
  • Minor improvements:
    • make request id publicly available;
    • use asio::executor_work_guard instead of asio::work (deprecated).



  • Boost::ASIO supported. RESTinio can optionally use Boost version of ASIO. See details: ASIO Support, Notes on building with Boost::ASIO.
  • Support Boost::Regex as regex engine for express-router.
  • Fix issue. Only path part of the request target must be a subject for doing match.
  • Add request target structure accessor to request header interface: http_request_header_t::path(), http_request_header_t::query(), http_request_header_t::fragment().


  • Express router: regex engine. Introduce a concept of regex engine, so express router can run on pcre/pcre2 engines or the one provided by user (generic_express_router_t and express_router_t classes).
  • Express router: route DSL. Update route to regex processing in order to stick with path-to-regexp project.
  • Express router: route params using string_view. Getting rid of using strings for storing parameters keys and values in route_params_t and using string_view (std::string_view if available).
  • Express router: route params casting. Introducing functions for converting route parameters to a specific type if the conversion is available (Casting parameters).
  • Express router: non matched request handler. A handler for non matched request can be set (Non matched request handler).
  • Express router: benchmark. Add a benchmark for testing performance on a given set of routes (described in file).
  • Improve query string params. Parsed parameters stored as string_view objects, thus requiring less space and less allocations.
  • Add cmake support for SObjectizer. Test and samples that depend on SObjectizer included to cmake scripts.
  • Add benchmarks. Add restinio benchmarks to repository.
  • Timer manager concept. Redesign timers. Introduce a concept of timer manager, that substitutes former timer factory concept.


  • Running server simplification. Add functions to deal with boilerplate code to run the server in simple cases.
  • Improve internal design. Redesign server start/stop logic.
  • Web Sockets. Basic support for Web Sockets.
  • Acceptor options. Custom options for socket can be set in settings.
  • Separate accept and create connection. Creating connection instance that involves allocations and initialization can be done in a context that is independent to acceptors context.
  • Concurrent accept. Server can accept several client connections concurrently.
  • Add uri helpers. A number of functions to work with query string see uri_helpers.hpp.


  • Improve header fields API. Type/enum support for known header fields and their values.
  • TLS support. Sopport for HTTPS with OpenSSL.
  • External buffers. Support external (constant) buffers support for body and/or body parts.


  • Routers for message handlers. Support for a URI dependent routing to a set of handlers (express-like router).
  • Bind localhost aliases. Accept “localhost” and “ip6-localhost” as address parameter for server to bound to.


  • Chunked transfer encoding. Support for chunked transfer encoding. Separate responses on header and body chunks, so it will be possible to send header and then body divided on chunks.
  • HTTP pipelining. HTTP pipelining support. Read, parse and call a handler for incoming requests independently. When responses become available send them to client in order of corresponding requests.


  • Address binding. Bind server to specific ip address.
  • Timeout control. Enable timeout guards for operations of receiving request (read and parse complete request), handling request, write response.
  • Logging. Support for logging of internal server work.
  • ASIO thread pool. Support ASIO running on a thread pool.
  • IPv6 support.