diff --git a/.clang-tidy b/.clang-tidy
index 3ab59c7..2d29f12 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -11,6 +11,7 @@ misc-*,
 -misc-no-recursion,
 -misc-unconventional-assign-operator,
 -misc-unused-parameters,
+-misc-use-anonymous-namespace,
 modernize-*,
 -modernize-avoid-c-arrays,
 -modernize-concat-nested-namespaces,
@@ -19,6 +20,7 @@ modernize-*,
 -modernize-use-trailing-return-type,
 -modernize-use-using,
 performance-*,
+-performance-avoid-endl,
 -performance-noexcept-move-constructor,
 readability-*,
 -readability-braces-around-statements,
diff --git a/CMakeLists.txt b/CMakeLists.txt
index a01d08c..61e1be6 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -48,6 +48,7 @@ configure_file(include/mp/config.h.in "${CMAKE_CURRENT_BINARY_DIR}/include/mp/co
 
 # Generated C++ Capn'Proto schema files
 capnp_generate_cpp(MP_PROXY_SRCS MP_PROXY_HDRS include/mp/proxy.capnp)
+set_source_files_properties(${MP_PROXY_SRCS} PROPERTIES SKIP_LINTING ON)
 
 # util library
 add_library(mputil OBJECT src/mp/util.cpp)
diff --git a/cmake/TargetCapnpSources.cmake b/cmake/TargetCapnpSources.cmake
index cdc86c6..f614bb1 100644
--- a/cmake/TargetCapnpSources.cmake
+++ b/cmake/TargetCapnpSources.cmake
@@ -66,18 +66,20 @@ function(target_capnp_sources target include_prefix)
 
   set(generated_headers "")
   foreach(capnp_file IN LISTS TCS_UNPARSED_ARGUMENTS)
-    add_custom_command(
-      OUTPUT ${capnp_file}.c++ ${capnp_file}.h ${capnp_file}.proxy-client.c++ ${capnp_file}.proxy-types.h ${capnp_file}.proxy-server.c++ ${capnp_file}.proxy-types.c++ ${capnp_file}.proxy.h
-      COMMAND Libmultiprocess::mpgen ${CMAKE_CURRENT_SOURCE_DIR} ${include_prefix} ${CMAKE_CURRENT_SOURCE_DIR}/${capnp_file} ${TCS_IMPORT_PATHS} ${MP_INCLUDE_DIR}
-      DEPENDS ${capnp_file}
-      VERBATIM
-    )
-    target_sources(${target} PRIVATE
+    set(generated_sources
       ${CMAKE_CURRENT_BINARY_DIR}/${capnp_file}.c++
       ${CMAKE_CURRENT_BINARY_DIR}/${capnp_file}.proxy-client.c++
       ${CMAKE_CURRENT_BINARY_DIR}/${capnp_file}.proxy-server.c++
       ${CMAKE_CURRENT_BINARY_DIR}/${capnp_file}.proxy-types.c++
     )
+    add_custom_command(
+      OUTPUT ${generated_sources} ${capnp_file}.h ${capnp_file}.proxy-types.h ${capnp_file}.proxy.h
+      COMMAND Libmultiprocess::mpgen ${CMAKE_CURRENT_SOURCE_DIR} ${include_prefix} ${CMAKE_CURRENT_SOURCE_DIR}/${capnp_file} ${TCS_IMPORT_PATHS} ${MP_INCLUDE_DIR}
+      DEPENDS ${capnp_file}
+      VERBATIM
+    )
+    target_sources(${target} PRIVATE ${generated_sources})
+    set_source_files_properties(${generated_sources} PROPERTIES SKIP_LINTING ON)
 
     list(APPEND generated_headers ${capnp_file}.h)
   endforeach()
diff --git a/example/calculator.cpp b/example/calculator.cpp
index 65f6476..4290d68 100644
--- a/example/calculator.cpp
+++ b/example/calculator.cpp
@@ -5,13 +5,15 @@
 #include <calculator.h>
 #include <fstream>
 #include <init.capnp.h>
-#include <init.capnp.proxy-types.h>
+#include <init.capnp.proxy.h> // NOLINT(misc-include-cleaner)
 #include <init.h>
 #include <iostream>
 #include <memory>
 #include <mp/proxy-io.h>
 #include <printer.h>
 #include <stdexcept>
+#include <string>
+#include <utility>
 
 class CalculatorImpl : public Calculator
 {
@@ -30,7 +32,7 @@ class InitImpl : public Init
     }
 };
 
-void LogPrint(bool raise, const std::string& message)
+static void LogPrint(bool raise, const std::string& message)
 {
     if (raise) throw std::runtime_error(message);
     std::ofstream("debug.log", std::ios_base::app) << message << std::endl;
@@ -43,7 +45,7 @@ int main(int argc, char** argv)
         return 1;
     }
     mp::EventLoop loop("mpcalculator", LogPrint);
-    int fd = std::stoi(argv[1]);
+    const int fd = std::stoi(argv[1]);
     std::unique_ptr<Init> init = std::make_unique<InitImpl>();
     mp::ServeStream<InitInterface>(loop, fd, *init);
     loop.loop();
diff --git a/example/example.cpp b/example/example.cpp
index 036dcb5..a4f84c5 100644
--- a/example/example.cpp
+++ b/example/example.cpp
@@ -4,17 +4,24 @@
 
 #include <filesystem>
 #include <fstream>
+#include <future>
 #include <init.capnp.h>
-#include <init.capnp.proxy-types.h>
+#include <init.capnp.proxy.h>
 #include <iostream>
 #include <mp/proxy-io.h>
+#include <mp/util.h>
+#include <stdexcept>
+#include <string>
+#include <thread>
+#include <tuple>
+#include <vector>
 
 namespace fs = std::filesystem;
 
-auto Spawn(mp::EventLoop& loop, const std::string& process_argv0, const std::string& new_exe_name)
+static auto Spawn(mp::EventLoop& loop, const std::string& process_argv0, const std::string& new_exe_name)
 {
     int pid;
-    int fd = mp::SpawnProcess(pid, [&](int fd) -> std::vector<std::string> {
+    const int fd = mp::SpawnProcess(pid, [&](int fd) -> std::vector<std::string> {
         fs::path path = process_argv0;
         path.remove_filename();
         path.append(new_exe_name);
@@ -23,7 +30,7 @@ auto Spawn(mp::EventLoop& loop, const std::string& process_argv0, const std::str
     return std::make_tuple(mp::ConnectStream<InitInterface>(loop, fd), pid);
 }
 
-void LogPrint(bool raise, const std::string& message)
+static void LogPrint(bool raise, const std::string& message)
 {
     if (raise) throw std::runtime_error(message);
     std::ofstream("debug.log", std::ios_base::app) << message << std::endl;
diff --git a/example/printer.cpp b/example/printer.cpp
index 0a51cdd..ccaed68 100644
--- a/example/printer.cpp
+++ b/example/printer.cpp
@@ -4,13 +4,14 @@
 
 #include <fstream>
 #include <init.capnp.h>
-#include <init.capnp.proxy-types.h>
+#include <init.capnp.proxy.h> // NOLINT(misc-include-cleaner)
 #include <init.h>
 #include <iostream>
 #include <memory>
 #include <mp/proxy-io.h>
 #include <printer.h>
 #include <stdexcept>
+#include <string>
 
 class PrinterImpl : public Printer
 {
@@ -24,7 +25,7 @@ class InitImpl : public Init
     std::unique_ptr<Printer> makePrinter() override { return std::make_unique<PrinterImpl>(); }
 };
 
-void LogPrint(bool raise, const std::string& message)
+static void LogPrint(bool raise, const std::string& message)
 {
     if (raise) throw std::runtime_error(message);
     std::ofstream("debug.log", std::ios_base::app) << message << std::endl;
@@ -37,7 +38,7 @@ int main(int argc, char** argv)
         return 1;
     }
     mp::EventLoop loop("mpprinter", LogPrint);
-    int fd = std::stoi(argv[1]);
+    const int fd = std::stoi(argv[1]);
     std::unique_ptr<Init> init = std::make_unique<InitImpl>();
     mp::ServeStream<InitInterface>(loop, fd, *init);
     loop.loop();
diff --git a/include/mp/proxy-io.h b/include/mp/proxy-io.h
index cc459d3..4430a42 100644
--- a/include/mp/proxy-io.h
+++ b/include/mp/proxy-io.h
@@ -63,7 +63,7 @@ struct ProxyClient<Thread> : public ProxyClientBase<Thread, ::capnp::Void>
     ProxyClient(const ProxyClient&) = delete;
     ~ProxyClient();
 
-    void setCleanup(std::function<void()> fn);
+    void setCleanup(const std::function<void()>& fn);
 
     //! Cleanup function to run when the connection is closed. If the Connection
     //! gets destroyed before this ProxyClient<Thread> object, this cleanup
@@ -247,7 +247,7 @@ struct Waiter
     template <typename Fn>
     void post(Fn&& fn)
     {
-        std::unique_lock<std::mutex> lock(m_mutex);
+        std::unique_lock<std::mutex> lock(m_mutex); // NOLINT(misc-const-correctness)
         assert(!m_fn);
         m_fn = std::move(fn);
         m_cv.notify_all();
@@ -269,7 +269,7 @@ struct Waiter
                 fn();
                 lock.lock();
             }
-            bool done = pred();
+            const bool done = pred();
             return done;
         });
     }
@@ -488,7 +488,7 @@ ProxyServerBase<Interface, Impl>::~ProxyServerBase()
             CleanupRun(fns);
         });
     }
-    assert(m_context.cleanup_fns.size() == 0);
+    assert(m_context.cleanup_fns.empty());
     std::unique_lock<std::mutex> lock(m_context.connection->m_loop.m_mutex);
     m_context.connection->m_loop.removeClient(lock);
 }
@@ -523,7 +523,7 @@ using ConnThread = ConnThreads::iterator;
 // Retrieve ProxyClient<Thread> object associated with this connection from a
 // map, or create a new one and insert it into the map. Return map iterator and
 // inserted bool.
-std::tuple<ConnThread, bool> SetThread(ConnThreads& threads, std::mutex& mutex, Connection* connection, std::function<Thread::Client()> make_thread);
+std::tuple<ConnThread, bool> SetThread(ConnThreads& threads, std::mutex& mutex, Connection* connection, const std::function<Thread::Client()>& make_thread);
 
 struct ThreadContext
 {
diff --git a/include/mp/proxy-types.h b/include/mp/proxy-types.h
index 6c1b1aa..e6465b7 100644
--- a/include/mp/proxy-types.h
+++ b/include/mp/proxy-types.h
@@ -39,17 +39,17 @@ struct StructField
 
     // clang-format off
     template<typename A = Accessor> auto get() const -> decltype(A::get(this->m_struct)) { return A::get(this->m_struct); }
-    template<typename A = Accessor> auto has() const -> typename std::enable_if<A::optional, bool>::type { return A::getHas(m_struct); }
-    template<typename A = Accessor> auto has() const -> typename std::enable_if<!A::optional && A::boxed, bool>::type { return A::has(m_struct); }
-    template<typename A = Accessor> auto has() const -> typename std::enable_if<!A::optional && !A::boxed, bool>::type { return true; }
-    template<typename A = Accessor> auto want() const -> typename std::enable_if<A::requested, bool>::type { return A::getWant(m_struct); }
-    template<typename A = Accessor> auto want() const -> typename std::enable_if<!A::requested, bool>::type { return true; }
+    template<typename A = Accessor> auto has() const -> std::enable_if_t<A::optional, bool> { return A::getHas(m_struct); }
+    template<typename A = Accessor> auto has() const -> std::enable_if_t<!A::optional && A::boxed, bool> { return A::has(m_struct); }
+    template<typename A = Accessor> auto has() const -> std::enable_if_t<!A::optional && !A::boxed, bool> { return true; }
+    template<typename A = Accessor> auto want() const -> std::enable_if_t<A::requested, bool> { return A::getWant(m_struct); }
+    template<typename A = Accessor> auto want() const -> std::enable_if_t<!A::requested, bool> { return true; }
     template<typename A = Accessor, typename... Args> decltype(auto) set(Args&&... args) const { return A::set(this->m_struct, std::forward<Args>(args)...); }
     template<typename A = Accessor, typename... Args> decltype(auto) init(Args&&... args) const { return A::init(this->m_struct, std::forward<Args>(args)...); }
-    template<typename A = Accessor> auto setHas() const -> typename std::enable_if<A::optional>::type { return A::setHas(m_struct); }
-    template<typename A = Accessor> auto setHas() const -> typename std::enable_if<!A::optional>::type { }
-    template<typename A = Accessor> auto setWant() const -> typename std::enable_if<A::requested>::type { return A::setWant(m_struct); }
-    template<typename A = Accessor> auto setWant() const -> typename std::enable_if<!A::requested>::type { }
+    template<typename A = Accessor> auto setHas() const -> std::enable_if_t<A::optional> { return A::setHas(m_struct); }
+    template<typename A = Accessor> auto setHas() const -> std::enable_if_t<!A::optional> { }
+    template<typename A = Accessor> auto setWant() const -> std::enable_if_t<A::requested> { return A::setWant(m_struct); }
+    template<typename A = Accessor> auto setWant() const -> std::enable_if_t<!A::requested> { }
     // clang-format on
 };
 
@@ -314,6 +314,9 @@ struct IterateFieldsHelper
     {
         static_cast<Derived*>(this)->handleField(std::forward<Arg1>(arg1), std::forward<Arg2>(arg2), ParamList());
     }
+private:
+    IterateFieldsHelper() = default;
+    friend Derived;
 };
 
 struct IterateFields : IterateFieldsHelper<IterateFields, 0>
@@ -372,14 +375,14 @@ struct ClientParam
         // position when unpacking tuple might be slower than pattern matching
         // approach in the stack overflow solution
         template <size_t I, typename... Args>
-        auto callBuild(Args&&... args) -> typename std::enable_if<(I < sizeof...(Types))>::type
+        auto callBuild(Args&&... args) -> std::enable_if_t<(I < sizeof...(Types))>
         {
             callBuild<I + 1>(std::forward<Args>(args)..., std::get<I>(m_client_param->m_values));
         }
 
         template <size_t I, typename Params, typename ParamList, typename... Values>
         auto callBuild(ClientInvokeContext& invoke_context, Params& params, ParamList, Values&&... values) ->
-            typename std::enable_if<(I == sizeof...(Types))>::type
+            std::enable_if_t<(I == sizeof...(Types))>
         {
             MaybeBuildField(std::integral_constant<bool, Accessor::in>(), ParamList(), invoke_context,
                 Make<StructField, Accessor>(params), std::forward<Values>(values)...);
@@ -400,14 +403,14 @@ struct ClientParam
         }
 
         template <int I, typename... Args>
-        auto callRead(Args&&... args) -> typename std::enable_if<(I < sizeof...(Types))>::type
+        auto callRead(Args&&... args) -> std::enable_if_t<(I < sizeof...(Types))>
         {
             callRead<I + 1>(std::forward<Args>(args)..., std::get<I>(m_client_param->m_values));
         }
 
         template <int I, typename Results, typename... Params, typename... Values>
         auto callRead(ClientInvokeContext& invoke_context, Results& results, TypeList<Params...>, Values&&... values)
-            -> typename std::enable_if<I == sizeof...(Types)>::type
+            -> std::enable_if_t<I == sizeof...(Types)>
         {
             MaybeReadField(std::integral_constant<bool, Accessor::out>(), TypeList<Decay<Params>...>(), invoke_context,
                 Make<StructField, Accessor>(results), ReadDestUpdate(values)...);
@@ -623,7 +626,7 @@ void clientInvoke(ProxyClient& proxy_client, const GetRequest& get_request, Fiel
                 } catch (...) {
                     exception = std::current_exception();
                 }
-                std::unique_lock<std::mutex> lock(invoke_context.thread_context.waiter->m_mutex);
+                std::unique_lock<std::mutex> lock(invoke_context.thread_context.waiter->m_mutex); // NOLINT(misc-const-correctness)
                 done = true;
                 invoke_context.thread_context.waiter->m_cv.notify_all();
             },
@@ -631,7 +634,7 @@ void clientInvoke(ProxyClient& proxy_client, const GetRequest& get_request, Fiel
                 kj_exception = kj::str("kj::Exception: ", e).cStr();
                 proxy_client.m_context.connection->m_loop.logPlain()
                     << "{" << invoke_context.thread_context.thread_name << "} IPC client exception " << kj_exception;
-                std::unique_lock<std::mutex> lock(invoke_context.thread_context.waiter->m_mutex);
+                std::unique_lock<std::mutex> lock(invoke_context.thread_context.waiter->m_mutex); // NOLINT(misc-const-correctness)
                 done = true;
                 invoke_context.thread_context.waiter->m_cv.notify_all();
             }));
@@ -648,7 +651,7 @@ void clientInvoke(ProxyClient& proxy_client, const GetRequest& get_request, Fiel
 //! duplication and branching in generic code that forwards calls to functions.
 template <typename Fn, typename Ret>
 auto ReplaceVoid(Fn&& fn, Ret&& ret) ->
-    typename std::enable_if<std::is_same<void, decltype(fn())>::value, decltype(ret())>::type
+    std::enable_if_t<std::is_same_v<void, decltype(fn())>, decltype(ret())>
 {
     fn();
     return ret();
@@ -657,7 +660,7 @@ auto ReplaceVoid(Fn&& fn, Ret&& ret) ->
 //! Overload of above for non-void `fn()` case.
 template <typename Fn, typename Ret>
 auto ReplaceVoid(Fn&& fn, Ret&& ret) ->
-    typename std::enable_if<!std::is_same<void, decltype(fn())>::value, decltype(fn())>::type
+    std::enable_if_t<!std::is_same_v<void, decltype(fn())>, decltype(fn())>
 {
     return fn();
 }
diff --git a/include/mp/proxy.h b/include/mp/proxy.h
index 92c0fa5..76be099 100644
--- a/include/mp/proxy.h
+++ b/include/mp/proxy.h
@@ -198,7 +198,7 @@ struct FunctionTraits<_Result (_Class::*const)(_Params...)>
     template <size_t N>
     using Param = typename std::tuple_element<N, std::tuple<_Params...>>::type;
     using Fields =
-        typename std::conditional<std::is_same<void, Result>::value, Params, TypeList<_Params..., _Result>>::type;
+        std::conditional_t<std::is_same_v<void, Result>, Params, TypeList<_Params..., _Result>>;
 };
 
 //! Traits class for a proxy method, providing the same
diff --git a/include/mp/util.h b/include/mp/util.h
index 032fc0f..0569c44 100644
--- a/include/mp/util.h
+++ b/include/mp/util.h
@@ -43,9 +43,9 @@ struct TypeList
 //! Example:
 //!   Make<std::pair>(5, true) // Constructs std::pair<int, bool>(5, true);
 template <template <typename...> class Class, typename... Types, typename... Args>
-Class<Types..., typename std::remove_reference<Args>::type...> Make(Args&&... args)
+Class<Types..., std::remove_reference_t<Args>...> Make(Args&&... args)
 {
-    return Class<Types..., typename std::remove_reference<Args>::type...>{std::forward<Args>(args)...};
+    return Class<Types..., std::remove_reference_t<Args>...>{std::forward<Args>(args)...};
 }
 
 //! Type helper splitting a TypeList into two halves at position index.
@@ -83,7 +83,7 @@ using RemoveCvRef = std::remove_cv_t<std::remove_reference_t<T>>;
 
 //! Type helper abbreviating std::decay.
 template <typename T>
-using Decay = typename std::decay<T>::type;
+using Decay = std::decay_t<T>;
 
 //! SFINAE helper, see using Require below.
 template <typename SfinaeExpr, typename Result_>
@@ -142,7 +142,7 @@ struct UnlockGuard
 template <typename Lock, typename Callback>
 void Unlock(Lock& lock, Callback&& callback)
 {
-    UnlockGuard<Lock> unlock(lock);
+    UnlockGuard<Lock> unlock(lock); // NOLINT(misc-const-correctness)
     callback();
 }
 
@@ -157,7 +157,7 @@ struct DestructorCatcher
     {
     }
     ~DestructorCatcher() noexcept try {
-    } catch (const kj::Exception& e) {
+    } catch (const kj::Exception& e) { // NOLINT(bugprone-empty-catch)
     }
 };
 
@@ -181,7 +181,7 @@ struct AsyncCallable
 
 //! Construct AsyncCallable object.
 template <typename Callable>
-AsyncCallable<typename std::remove_reference<Callable>::type> MakeAsyncCallable(Callable&& callable)
+AsyncCallable<std::remove_reference_t<Callable>> MakeAsyncCallable(Callable&& callable)
 {
     return std::move(callable);
 }
diff --git a/src/mp/gen.cpp b/src/mp/gen.cpp
index 93b001f..bdbee4b 100644
--- a/src/mp/gen.cpp
+++ b/src/mp/gen.cpp
@@ -7,11 +7,22 @@
 
 #include <algorithm>
 #include <capnp/schema-parser.h>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
 #include <errno.h>
 #include <fstream>
+#include <functional>
+#include <kj/array.h>
+#include <kj/common.h>
+#include <kj/filesystem.h>
+#include <kj/memory.h>
+#include <kj/string.h>
 #include <map>
 #include <set>
 #include <sstream>
+#include <stdexcept>
+#include <string>
 #include <system_error>
 #include <unistd.h>
 #include <vector>
@@ -64,7 +75,7 @@ static bool GetAnnotationInt32(const Reader& reader, uint64_t id, int32_t* resul
     return false;
 }
 
-void ForEachMethod(const capnp::InterfaceSchema& interface, const std::function<void(const capnp::InterfaceSchema& interface, const capnp::InterfaceSchema::Method)>& callback)
+static void ForEachMethod(const capnp::InterfaceSchema& interface, const std::function<void(const capnp::InterfaceSchema& interface, const capnp::InterfaceSchema::Method)>& callback)
 {
     for (const auto super : interface.getSuperclasses()) {
         ForEachMethod(super, callback);
@@ -78,7 +89,7 @@ using CharSlice = kj::ArrayPtr<const char>;
 
 // Overload for any type with a string .begin(), like kj::StringPtr and kj::ArrayPtr<char>.
 template <class OutputStream, class Array, const char* Enable = decltype(std::declval<Array>().begin())()>
-OutputStream& operator<<(OutputStream& os, const Array& array)
+static OutputStream& operator<<(OutputStream& os, const Array& array)
 {
     os.write(array.begin(), array.size());
     return os;
@@ -96,14 +107,14 @@ struct Format
     std::ostringstream m_os;
 };
 
-std::string Cap(kj::StringPtr str)
+static std::string Cap(kj::StringPtr str)
 {
     std::string result = str;
     if (!result.empty() && 'a' <= result[0] && result[0] <= 'z') result[0] -= 'a' - 'A';
     return result;
 }
 
-bool BoxedType(const ::capnp::Type& type)
+static bool BoxedType(const ::capnp::Type& type)
 {
     return !(type.isVoid() || type.isBool() || type.isInt8() || type.isInt16() || type.isInt32() || type.isInt64() ||
              type.isUInt8() || type.isUInt16() || type.isUInt32() || type.isUInt64() || type.isFloat32() ||
@@ -123,7 +134,7 @@ bool BoxedType(const ::capnp::Type& type)
 // include_prefix is "/a/b/c" include lines like
 // "#include <d/file.capnp.proxy.h>" "#include <d/file.capnp.proxy-types.h>"i
 // will be generated.
-void Generate(kj::StringPtr src_prefix,
+static void Generate(kj::StringPtr src_prefix,
     kj::StringPtr include_prefix,
     kj::StringPtr src_file,
     const std::vector<kj::StringPtr>& import_paths,
@@ -151,7 +162,7 @@ void Generate(kj::StringPtr src_prefix,
     }
 
     std::string include_base = include_path;
-    std::string::size_type p = include_base.rfind('.');
+    const std::string::size_type p = include_base.rfind('.');
     if (p != std::string::npos) include_base.erase(p);
 
     std::vector<std::string> args;
@@ -165,19 +176,19 @@ void Generate(kj::StringPtr src_prefix,
     }
     args.emplace_back("--output=" capnp_PREFIX "/bin/capnpc-c++");
     args.emplace_back(src_file);
-    int pid = fork();
+    const int pid = fork();
     if (pid == -1) {
         throw std::system_error(errno, std::system_category(), "fork");
     }
     if (!pid) {
         mp::ExecProcess(args);
     }
-    int status = mp::WaitProcess(pid);
+    const int status = mp::WaitProcess(pid);
     if (status) {
         throw std::runtime_error("Invoking " capnp_PREFIX "/bin/capnp failed");
     }
 
-    capnp::SchemaParser parser;
+    const capnp::SchemaParser parser;
     auto directory_pointers = kj::heapArray<const kj::ReadableDirectory*>(import_dirs.size());
     for (size_t i = 0; i < import_dirs.size(); ++i) {
         directory_pointers[i] = import_dirs[i].get();
@@ -203,8 +214,11 @@ void Generate(kj::StringPtr src_prefix,
     cpp_types << "namespace mp {\n";
 
     std::string guard = output_path;
-    std::transform(guard.begin(), guard.end(), guard.begin(), [](unsigned char c) {
-        return ('0' <= c && c <= '9') ? c : ('A' <= c && c <= 'Z') ? c : ('a' <= c && c <= 'z') ? c - 'a' + 'A' : '_';
+    std::transform(guard.begin(), guard.end(), guard.begin(), [](unsigned char c) -> unsigned char {
+        if ('0' <= c && c <= '9') return c;
+        if ('A' <= c && c <= 'Z') return c;
+        if ('a' <= c && c <= 'z') return c - 'a' + 'A';
+        return '_';
     });
 
     std::ofstream inl(output_path + ".proxy-types.h");
@@ -244,7 +258,7 @@ void Generate(kj::StringPtr src_prefix,
     GetAnnotationText(file_schema.getProto(), NAMESPACE_ANNOTATION_ID, &message_namespace);
 
     std::string base_name = include_base;
-    size_t output_slash = base_name.rfind('/');
+    const size_t output_slash = base_name.rfind('/');
     if (output_slash != std::string::npos) {
         base_name.erase(0, output_slash + 1);
     }
@@ -260,7 +274,7 @@ void Generate(kj::StringPtr src_prefix,
 
     auto add_accessor = [&](kj::StringPtr name) {
         if (!accessors_done.insert(name).second) return;
-        std::string cap = Cap(name);
+        const std::string cap = Cap(name);
         accessors << "struct " << cap << "\n";
         accessors << "{\n";
         accessors << "    template<typename S> static auto get(S&& s) -> decltype(s.get" << cap << "()) { return s.get" << cap << "(); }\n";
@@ -368,19 +382,19 @@ void Generate(kj::StringPtr src_prefix,
             server << "    using ProxyServerCustom::ProxyServerCustom;\n";
             server << "    ~ProxyServer();\n";
 
-            std::ostringstream client_construct;
-            std::ostringstream client_destroy;
+            const std::ostringstream client_construct;
+            const std::ostringstream client_destroy;
 
             int method_ordinal = 0;
             ForEachMethod(interface, [&] (const capnp::InterfaceSchema& method_interface, const capnp::InterfaceSchema::Method& method) {
-                kj::StringPtr method_name = method.getProto().getName();
+                const kj::StringPtr method_name = method.getProto().getName();
                 kj::StringPtr proxied_method_name = method_name;
                 GetAnnotationText(method.getProto(), NAME_ANNOTATION_ID, &proxied_method_name);
 
                 const std::string method_prefix = Format() << message_namespace << "::" << method_interface.getShortDisplayName()
                                                            << "::" << Cap(method_name);
-                bool is_construct = method_name == "construct";
-                bool is_destroy = method_name == "destroy";
+                const bool is_construct = method_name == "construct";
+                const bool is_destroy = method_name == "destroy";
 
                 struct Field
                 {
@@ -484,7 +498,13 @@ void Generate(kj::StringPtr src_prefix,
                     auto field_type = f.getType();
 
                     std::ostringstream field_flags;
-                    field_flags << (!field.param_is_set ? "FIELD_OUT" : field.result_is_set ? "FIELD_IN | FIELD_OUT" : "FIELD_IN");
+                    if (!field.param_is_set) {
+                        field_flags << "FIELD_OUT";
+                    } else if (field.result_is_set) {
+                        field_flags << "FIELD_IN | FIELD_OUT";
+                    } else {
+                        field_flags << "FIELD_IN";
+                    }
                     if (field.optional) field_flags << " | FIELD_OPTIONAL";
                     if (field.requested) field_flags << " | FIELD_REQUESTED";
                     if (BoxedType(field_type)) field_flags << " | FIELD_BOXED";
@@ -530,9 +550,9 @@ void Generate(kj::StringPtr src_prefix,
                     server_invoke_end << ")";
                 }
 
-                std::string static_str{is_construct || is_destroy ? "static " : ""};
-                std::string super_str{is_construct || is_destroy ? "Super& super" : ""};
-                std::string self_str{is_construct || is_destroy ? "super" : "*this"};
+                const std::string static_str{is_construct || is_destroy ? "static " : ""};
+                const std::string super_str{is_construct || is_destroy ? "Super& super" : ""};
+                const std::string self_str{is_construct || is_destroy ? "super" : "*this"};
 
                 client << "    using M" << method_ordinal << " = ProxyClientMethodTraits<" << method_prefix
                        << "Params>;\n";
diff --git a/src/mp/proxy.cpp b/src/mp/proxy.cpp
index 8f34e82..ca094e3 100644
--- a/src/mp/proxy.cpp
+++ b/src/mp/proxy.cpp
@@ -31,6 +31,7 @@
 #include <string>
 #include <sys/socket.h>
 #include <thread>
+#include <tuple>
 #include <unistd.h>
 #include <utility>
 
@@ -102,7 +103,7 @@ Connection::~Connection()
         m_sync_cleanup_fns.pop_front();
     }
     while (!m_async_cleanup_fns.empty()) {
-        std::unique_lock<std::mutex> lock(m_loop.m_mutex);
+        std::unique_lock<std::mutex> lock(m_loop.m_mutex); // NOLINT(misc-const-correctness)
         m_loop.m_async_fns.emplace_back(std::move(m_async_cleanup_fns.front()));
         m_async_cleanup_fns.pop_front();
     }
@@ -113,7 +114,7 @@ Connection::~Connection()
 
 CleanupIt Connection::addSyncCleanup(std::function<void()> fn)
 {
-    std::unique_lock<std::mutex> lock(m_loop.m_mutex);
+    std::unique_lock<std::mutex> lock(m_loop.m_mutex); // NOLINT(misc-const-correctness)
     // Add cleanup callbacks to the front of list, so sync cleanup functions run
     // in LIFO order. This is a good approach because sync cleanup functions are
     // added as client objects are created, and it is natural to clean up
@@ -127,13 +128,13 @@ CleanupIt Connection::addSyncCleanup(std::function<void()> fn)
 
 void Connection::removeSyncCleanup(CleanupIt it)
 {
-    std::unique_lock<std::mutex> lock(m_loop.m_mutex);
+    std::unique_lock<std::mutex> lock(m_loop.m_mutex); // NOLINT(misc-const-correctness)
     m_sync_cleanup_fns.erase(it);
 }
 
 void Connection::addAsyncCleanup(std::function<void()> fn)
 {
-    std::unique_lock<std::mutex> lock(m_loop.m_mutex);
+    std::unique_lock<std::mutex> lock(m_loop.m_mutex); // NOLINT(misc-const-correctness)
     // Add async cleanup callbacks to the back of the list. Unlike the sync
     // cleanup list, this list order is more significant because it determines
     // the order server objects are destroyed when there is a sudden disconnect,
@@ -169,7 +170,7 @@ EventLoop::EventLoop(const char* exe_name, LogFn log_fn, void* context)
 EventLoop::~EventLoop()
 {
     if (m_async_thread.joinable()) m_async_thread.join();
-    std::lock_guard<std::mutex> lock(m_mutex);
+    std::lock_guard<std::mutex> lock(m_mutex); // NOLINT(misc-const-correctness)
     KJ_ASSERT(m_post_fn == nullptr);
     KJ_ASSERT(m_async_fns.empty());
     KJ_ASSERT(m_wait_fd == -1);
@@ -192,7 +193,7 @@ void EventLoop::loop()
     int post_fd{m_post_fd};
     char buffer = 0;
     for (;;) {
-        size_t read_bytes = wait_stream->read(&buffer, 0, 1).wait(m_io_context.waitScope);
+        const size_t read_bytes = wait_stream->read(&buffer, 0, 1).wait(m_io_context.waitScope);
         if (read_bytes != 1) throw std::logic_error("EventLoop wait_stream closed unexpectedly");
         std::unique_lock<std::mutex> lock(m_mutex);
         if (m_post_fn) {
@@ -212,7 +213,7 @@ void EventLoop::loop()
     log() << "EventLoop::loop bye.";
     wait_stream = nullptr;
     KJ_SYSCALL(::close(post_fd));
-    std::unique_lock<std::mutex> lock(m_mutex);
+    std::unique_lock<std::mutex> lock(m_mutex); // NOLINT(misc-const-correctness)
     m_wait_fd = -1;
     m_post_fd = -1;
 }
@@ -220,7 +221,8 @@ void EventLoop::loop()
 void EventLoop::post(const std::function<void()>& fn)
 {
     if (std::this_thread::get_id() == m_thread_id) {
-        return fn();
+        fn();
+        return;
     }
     std::unique_lock<std::mutex> lock(m_mutex);
     m_cv.wait(lock, [this] { return m_post_fn == nullptr; });
@@ -258,7 +260,7 @@ void EventLoop::startAsyncThread(std::unique_lock<std::mutex>& lock)
             while (true) {
                 if (!m_async_fns.empty()) {
                     addClient(lock);
-                    std::function<void()> fn = std::move(m_async_fns.front());
+                    const std::function<void()> fn = std::move(m_async_fns.front());
                     m_async_fns.pop_front();
                     Unlock(lock, fn);
                     removeClient(lock);
@@ -280,9 +282,9 @@ bool EventLoop::done(std::unique_lock<std::mutex>& lock)
     return m_num_clients == 0 && m_async_fns.empty();
 }
 
-std::tuple<ConnThread, bool> SetThread(ConnThreads& threads, std::mutex& mutex, Connection* connection, std::function<Thread::Client()> make_thread)
+std::tuple<ConnThread, bool> SetThread(ConnThreads& threads, std::mutex& mutex, Connection* connection, const std::function<Thread::Client()>& make_thread)
 {
-    std::unique_lock<std::mutex> lock(mutex);
+    std::unique_lock<std::mutex> lock(mutex); // NOLINT(misc-const-correctness)
     auto thread = threads.find(connection);
     if (thread != threads.end()) return {thread, false};
     thread = threads.emplace(
@@ -299,7 +301,7 @@ std::tuple<ConnThread, bool> SetThread(ConnThreads& threads, std::mutex& mutex,
         // try unregister this callback after connection is destroyed.
         thread->second.m_cleanup_it.reset();
         // Remove connection pointer about to be destroyed from the map
-        std::unique_lock<std::mutex> lock(mutex);
+        std::unique_lock<std::mutex> lock(mutex); // NOLINT(misc-const-correctness)
         threads.erase(thread);
     });
     return {thread, true};
@@ -315,7 +317,7 @@ ProxyClient<Thread>::~ProxyClient()
     }
 }
 
-void ProxyClient<Thread>::setCleanup(std::function<void()> fn)
+void ProxyClient<Thread>::setCleanup(const std::function<void()>& fn)
 {
     assert(fn);
     assert(!m_cleanup_it);
@@ -339,7 +341,7 @@ ProxyServer<Thread>::~ProxyServer()
     assert(m_thread_context.waiter.get());
     std::unique_ptr<Waiter> waiter;
     {
-        std::unique_lock<std::mutex> lock(m_thread_context.waiter->m_mutex);
+        std::unique_lock<std::mutex> lock(m_thread_context.waiter->m_mutex); // NOLINT(misc-const-correctness)
         //! Reset thread context waiter pointer, as shutdown signal for done
         //! lambda passed as waiter->wait() argument in makeThread code below.
         waiter = std::move(m_thread_context.waiter);
@@ -367,7 +369,7 @@ ProxyServer<ThreadMap>::ProxyServer(Connection& connection) : m_connection(conne
 
 kj::Promise<void> ProxyServer<ThreadMap>::makeThread(MakeThreadContext context)
 {
-    std::string from = context.getParams().getName();
+    const std::string from = context.getParams().getName();
     std::promise<ThreadContext*> thread_context;
     std::thread thread([&thread_context, from, this]() {
         g_thread_context.thread_name = ThreadName(m_connection.m_loop.m_exe_name) + " (from " + from + ")";
diff --git a/src/mp/util.cpp b/src/mp/util.cpp
index 107985e..6a25cfc 100644
--- a/src/mp/util.cpp
+++ b/src/mp/util.cpp
@@ -6,21 +6,22 @@
 #include <mp/util.h>
 
 #include <errno.h>
-#include <kj/array.h>
+#include <kj/common.h>
+#include <kj/string-tree.h>
 #include <pthread.h>
 #include <sstream>
 #include <stdio.h>
+#include <string>
 #include <sys/resource.h>
 #include <sys/socket.h>
-#include <sys/types.h>
-#include <sys/un.h>
 #include <sys/wait.h>
 #include <system_error>
-#include <thread>
 #include <unistd.h>
+#include <utility>
+#include <vector>
 
 #if __linux__
-#include <syscall.h>
+#include <sys/syscall.h>
 #endif
 
 #ifdef HAVE_PTHREAD_GETTHREADID_NP
@@ -80,7 +81,7 @@ std::string LogEscape(const kj::StringTree& string)
     std::string result;
     string.visit([&](const kj::ArrayPtr<const char>& piece) {
         if (result.size() > MAX_SIZE) return;
-        for (char c : piece) {
+        for (const char c : piece) {
             if (c == '\\') {
                 result.append("\\\\");
             } else if (c < 0x20 || c > 0x7e) {
@@ -116,7 +117,7 @@ int SpawnProcess(int& pid, FdToArgsFn&& fd_to_args)
     }
     if (!pid) {
         // Child process must close all potentially open descriptors, except socket 0.
-        int maxFd = MaxFd();
+        const int maxFd = MaxFd();
         for (int fd = 3; fd < maxFd; ++fd) {
             if (fd != fds[0]) {
                 close(fd);
diff --git a/test/mp/test/foo.h b/test/mp/test/foo.h
index ceb8dcc..4623b78 100644
--- a/test/mp/test/foo.h
+++ b/test/mp/test/foo.h
@@ -21,7 +21,7 @@ struct FooStruct
     std::vector<bool> vbool;
 };
 
-enum class FooEnum : int { ONE = 1, TWO = 2, };
+enum class FooEnum : int { ONE = 1, TWO = 2, }; // NOLINT(performance-enum-size)
 
 struct FooCustom
 {
diff --git a/test/mp/test/test.cpp b/test/mp/test/test.cpp
index 661ae69..7721d41 100644
--- a/test/mp/test/test.cpp
+++ b/test/mp/test/test.cpp
@@ -2,15 +2,22 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <mp/proxy-types.h>
+#include <mp/proxy-io.h>
 #include <mp/test/foo.capnp.h>
 #include <mp/test/foo.capnp.proxy.h>
 #include <mp/test/foo.h>
 
+#include <capnp/capability.h>
+#include <cstdio>
 #include <future>
+#include <functional>
+#include <memory>
 #include <kj/common.h>
 #include <kj/memory.h>
 #include <kj/test.h>
+#include <string>
+#include <thread>
+#include <utility>
 
 namespace mp {
 namespace test {