diff --git a/ut b/ut
index 7385556..902075a 100644
--- a/ut
+++ b/ut
@@ -1,30 +1,44 @@
 // <!--
+// The MIT License (MIT)
 //
-// Copyright (c) 2024 Kris Jusiak (kris at jusiak dot net)
+// Copyright (c) 2024 Kris Jusiak <kris@jusiak.net>
 //
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
 //
-#ifdef README
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+#if 0
 // -->
-[![Boost Licence](http://img.shields.io/badge/license-boost-blue.svg)](http://www.boost.org/LICENSE_1_0.txt)
-[![Version](https://badge.fury.io/gh/qlibs%2Fut.svg)](https://github.com/qlibs/ut/releases)
-[![build](https://img.shields.io/badge/build-blue.svg)](https://godbolt.org/z/f3WPzK5xf)
-[![Try it online](https://img.shields.io/badge/try%20it-online-blue.svg)](https://godbolt.org/z/MG5cjnsbM)
+[Overview](#Overview) / [Examples](#Examples) / [API](#API) / [FAQ](#FAQ)
 
----------------------------------------
+## UT: C++20 Unit-Testing library
 
-> "If you liked it then you `"should have put a"_test` on it", Beyonce rule
+  > "If you liked it then you `"should have put a"_test` on it", Beyonce rule
 
-## UT: C++20 minimal unit-testing library
+[![MIT Licence](http://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/license/mit)
+[![Version](https://img.shields.io/github/v/release/qlibs/ut)](https://github.com/qlibs/ut/releases)
+[![Build](https://img.shields.io/badge/build-green.svg)](https://godbolt.org/z/3qT4vc9nY)
+[![Try it online](https://img.shields.io/badge/try%20it-online-blue.svg)](https://godbolt.org/z/MG5cjnsbM)
 
-> https://en.wikipedia.org/wiki/Unit_testing
+  > https://en.wikipedia.org/wiki/Unit_testing
 
 ### Features
 
-- Single header (https://raw.githubusercontent.com/qliqbs/ut/main/ut)
-    - Easy integration (see [FAQ](#faq))
+- Single header (https://raw.githubusercontent.com/qlibs/ut/main/ut - for integration see [FAQ](https://github.com/qlibs/.github/blob/main/profile/INTEGRATION.md))
 - Compile-time first (executes tests at compile-time and/or run-time)
     - Detects memory leaks and UBs at compile-time*
 - Explicit by design (no implicit conversions, narrowing, epsilon-less floating point comparisions, ...)
@@ -33,9 +47,9 @@
 - Compiles cleanly with ([`-fno-exceptions -fno-rtti -Wall -Wextra -Werror -pedantic -pedantic-errors`](https://godbolt.org/z/ceK6qsx68))
 - Fast compilation times (see [compilation times](#comp))
 - Fast run-time execution (see [performance](#perf))
-- Verifies itself upon include (aka run all tests via static_asserts but it can be disabled - see [FAQ](#faq))
+- Verifies itself upon include (can be disabled with `-DNTEST` - see [FAQ](https://github.com/qlibs/.github/blob/main/profile/NTEST.md))
 
-> Based on the `constexpr` ability of given compiler/standard
+> \*Based on the `constexpr` ability of given compiler/standard
 
 ### Requirements
 
@@ -43,7 +57,7 @@
 
 ---
 
-### Examples
+### Overview
 
 > Hello world (https://godbolt.org/z/MG5cjnsbM)
 
@@ -213,6 +227,8 @@ int main() {
 
 ---
 
+### Examples
+
 > Reflection integration (https://godbolt.org/z/v8GG4hfbW)
 
 ```cpp
@@ -291,20 +307,20 @@ time $CXX -x c++ -std=c++20 ut -c                  # 0.049s
 [ut]: time $CXX benchmark.cpp -std=c++20           # 0m0.813s
 [ut]: time $CXX benchmark.cpp -std=c++20 -DNTEST   # 0m0.758s
 -------------------------------------------------------------------------
-[ut] https://github.com/qlibs/ut/releases/tag/v2.1.2
+[ut] https://github.com/qlibs/ut/releases/tag/v2.1.3
 ```
 
 <a name="perf"></a>
 ### Performance
 
-> Benchmark - 100 tests, 1000 asserts (https://godbolt.org/z/6WzxvjEex)
+> Benchmark - 100 tests, 1000 asserts (https://godbolt.org/z/xKx45s4xq)
 
 ```cpp
 time ./benchmark # 0m0.002s (-O3)
 time ./benchmark # 0m0.013s (-g)
 ```
 
-> X86-64 assembly -O3 (https://godbolt.org/z/x6GYbs4hT)
+> X86-64 assembly -O3 (https://godbolt.org/z/rqbsafaE6)
 
 ```cpp
 int main() {
@@ -329,7 +345,7 @@ main:
   mov  dword ptr [rax + 16], 6
   lea  rcx, [rip + template parameter object for fixed_string
   mov  qword ptr [rax + 24], rcx
-  inc  dword ptr [rip + ut::v2_1_1::cfg<ut::v2_1_1::override>+52]
+  inc  dword ptr [rip + ut::cfg<ut::override>+52]
   mov  rax, qword ptr [rip + ut::cfg<ut::override>+136]
   mov  ecx, dword ptr [rax + 8]
   mov  edx, dword ptr [rax + 92]
@@ -499,10 +515,13 @@ enum class mode {
   compile_time
 };
 
-template<mode Mode>
-struct test_begin {
+template<class T>
+struct run {
+  T test{};
   const char* file_name{};
-  int line{}; const char* name{};
+  int line{};
+  const char* name{};
+  const char* filter{};
 };
 
 template<mode Mode>
@@ -587,50 +606,31 @@ template <class...> inline auto cfg = default_cfg{};
 ```
 
 ```cpp
-#define UT 2'1'2                // Current library version (SemVer)
 #define UT_RUN_TIME_ONLY        // If defined tests will be executed
                                 // at run-time + static_assert tests
 #define UT_COMPILE_TIME_ONLY    // If defined only compile-time tests
                                 // will be executed
-#define NTEST                   // If defined it disables running
-                                // static_asserts tests for the UT library
-                                // (user tests are not affected)
+```
+
+```cpp
+UT_FILTER                       // If env is set only tests which match
+                                // regex will be executed
 ```
 
 ---
 
 ### FAQ
 
-- Can I disable running tests at compile-time for faster compilation times?
-
-    > When `NTEST` is defined static_asserts tests wont be executed upon inclusion.
-    Note: Use with caution as disabling tests means that there are no guarantees upon inclusion that the given compiler/env combination works as expected.
-
-- How to integrate with CMake/CPM?
-
-    ```
-    CPMAddPackage(
-      Name ut
-      GITHUB_REPOSITORY qlibs/ut
-      GIT_TAG v2.1.2
-    )
-    add_library(ut INTERFACE)
-    target_include_directories(ut SYSTEM INTERFACE ${ut_SOURCE_DIR})
-    add_library(ut::ut ALIAS ut)
-    ```
-
-    ```
-    target_link_libraries(${PROJECT_NAME} ut::ut);
-    ```
-
 - Similar projects?
     > [ut](https://github.com/boost-ext/ut), [catch2](https://github.com/catchorg/Catch2), [googletest](https://github.com/google/googletest), [gunit](https://github.com/cpp-testing/GUnit), [boost.test](https://www.boost.org/doc/libs/latest/libs/test/doc/html/index.html)
 <!--
-#else
-#ifndef UT
-#define UT 2'1'2 // SemVer
+#endif
+
+#pragma once
 
-namespace ut::inline v2_1_2 {
+extern "C" char *getenv(const char *) throw();
+
+namespace ut::inline v2_1_3 {
 namespace type_traits {
 template<class, class> inline constexpr auto is_same_v = false;
 template<class T> inline constexpr auto is_same_v<T, T> = true;
@@ -653,9 +653,36 @@ template<unsigned Size> struct fixed_string {
   constexpr friend auto operator<<(auto& os, const fixed_string& fs) -> decltype(auto) { return os << fs.storage; }
   char storage[Size]{};
 };
+[[nodiscard]] constexpr auto match(const auto pattern, const auto str) -> bool {
+  if (not bool(pattern)) { return true; }
+  if (not *pattern) { return not *str; }
+
+  if (not *str) {
+    return pattern[0] == '*' ? match(&pattern[1], str) : false;
+  }
+
+  if (pattern[0] != '?' and pattern[0] != '*' and pattern[0] != str[0]) {
+    return false;
+  }
+
+  if (pattern[0] == '*') {
+    auto tmp = str;
+    auto i = 0u;
+    while (tmp++) {
+      if (match(&pattern[1], &str[i++])) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  return match(&pattern[1], &str[1]);
+}
 } // utility
 namespace events {
 enum class mode { run_time, compile_time };
+template<class T>
+struct run { T test{}; const char* file_name{}; int line{}; const char* name{}; const char* filter{}; };
 template<mode Mode> struct test_begin { const char* file_name{}; int line{}; const char* name{}; };
 template<mode Mode> struct test_end { const char* file_name{}; int line{}; const char* name{}; enum { FAILED, PASSED, COMPILE_TIME } result{}; };
 template<class TExpr> struct assert_pass { const char* file_name{}; int line{}; TExpr expr{}; };
@@ -755,10 +782,10 @@ struct reporter {
 
 template<class TReporter>
 struct runner {
-  template<class Test> constexpr auto on(Test test, const char* file_name, int line, const char* name) -> bool {
+  template<class Test> constexpr auto on(events::run<Test> run) -> bool {
     if (__builtin_is_constant_evaluated()) {
       if constexpr (!type_traits::is_mutable_lambda_v<decltype(&Test::operator())>) {
-        test();
+        run.test();
         return true;
       } else {
         return false;
@@ -766,16 +793,18 @@ struct runner {
     } else {
       #ifndef UT_RUN_TIME_ONLY
         if constexpr (!type_traits::is_mutable_lambda_v<decltype(&Test::operator())> && !type_traits::has_capture_lambda_v<Test>) {
-          reporter.on(events::test_begin<events::mode::compile_time>{file_name, line, name});
-          static_assert((test(), "[FAILED]"));
-          reporter.on(events::test_end<events::mode::compile_time>{file_name, line, name});
+          reporter.on(events::test_begin<events::mode::compile_time>{run.file_name, run.line, run.name});
+          static_assert((run.test(), R"([FAILED] Compile-time expectation failed. The error below should indicate the issue. If it's not an assertion it might be that the std and/or compiler don't support running the test at compile-time. In such case mark the test as `mutable` to force run-time only execution. For example: `"run-time"_test = [] mutable { ... }`.)"));
+          reporter.on(events::test_end<events::mode::compile_time>{run.file_name, run.line, run.name});
         }
       #endif
 
       #ifndef UT_COMPILE_TIME_ONLY
-        reporter.on(events::test_begin<events::mode::run_time>{file_name, line, name});
-        test();
-        reporter.on(events::test_end<events::mode::run_time>{file_name, line, name});
+        if (utility::match(run.filter, run.name)) {
+          reporter.on(events::test_begin<events::mode::run_time>{run.file_name, run.line, run.name});
+          run.test();
+          reporter.on(events::test_end<events::mode::run_time>{run.file_name, run.line, run.name});
+        }
       #endif
     }
     return true;
@@ -791,7 +820,7 @@ template<class, class> class basic_ostream;
 extern basic_ostream<char, char_traits<char>> clog; // only used if defined
 } // namespace std
 
-namespace ut::inline v2_1_2 {
+namespace ut::inline v2_1_3 {
 template<class...>
 struct default_cfg {
   struct {
@@ -831,7 +860,7 @@ void failed(); /// fail in constexpr context
 inline constexpr struct {
   constexpr auto operator()(auto expr, const char* file_name = __builtin_FILE(), int line = __builtin_LINE()) const {
     if constexpr (constexpr auto supported = type_traits::is_same_v<bool, decltype(expr)> || !requires { static_cast<bool>(expr); }; supported) {
-      static_assert(!supported, "[ERROR] Expression required: expect(a == b)");
+      static_assert(!supported, "[ERROR] Expression required - `expect(lhs == rhs)`. For example: `expect(3_i == sum(1, 2))`.");
     } else {
       bool result{};
       if (result = static_cast<bool>(expr); __builtin_is_constant_evaluated()) {
@@ -848,7 +877,7 @@ inline constexpr struct {
   struct fatal_expr {
     constexpr fatal_expr(auto expr, const char* file_name = __builtin_FILE(), int line = __builtin_LINE()) {
       if constexpr (constexpr auto supported = type_traits::is_same_v<bool, decltype(expr)> || !requires { static_cast<bool>(expr); }; supported) {
-        static_assert(!supported, "[ERROR] Expression required: expect[a == b]");
+        static_assert(!supported, "[ERROR] Expression required - `expect[lhs == rhs]`. For example: `expect[3_i == sum(1, 2)]`.");
       } else {
         if (result = static_cast<bool>(expr); __builtin_is_constant_evaluated()) {
           if (!result) { detail::failed(); }
@@ -856,13 +885,12 @@ inline constexpr struct {
           detail::cfg(expr).reporter.on(events::assert_pass{file_name, line, expr});
         } else {
           detail::cfg(expr).reporter.on(events::assert_fail{file_name, line, expr});
-          detail::cfg(expr).reporter.on(events::fatal{});
         }
       }
     }
     bool result{};
   };
-  constexpr auto operator[](fatal_expr e) const { return log{e.result}; } /// multiple and/or default parameters requires C++23
+  constexpr auto operator[](fatal_expr e) const { return fatal_log{e.result}; } /// multiple and/or default parameters requires C++23
 
 private:
   struct log {
@@ -872,6 +900,17 @@ private:
     }
     bool result{};
   };
+  template<auto tag = []{}>
+  struct fatal_log {
+    template<class TMsg> constexpr const auto& operator<<(const TMsg& msg) const {
+      detail::cfg(msg).outputter.on(events::log<TMsg>{msg, result});
+      return *this;
+    }
+    constexpr ~fatal_log() {
+      detail::cfg(tag).reporter.on(events::fatal{});
+    }
+    bool result{};
+  };
 } expect{};
 
 struct suite {
@@ -883,7 +922,13 @@ template<utility::fixed_string Name>
 struct test {
   struct run {
     template<class T> constexpr run(T test, const char* file_name = __builtin_FILE(), int line = __builtin_LINE())
-      : result{cfg(test).runner.on(test, file_name, line, Name.data())}
+      : result{[&] {
+          if (__builtin_is_constant_evaluated()) {
+            return cfg(test).runner.on(events::run{test, file_name, line, Name.data()});
+          } else {
+            return cfg(test).runner.on(events::run{test, file_name, line, Name.data(), getenv("UT_FILTER")});
+          }
+        }()}
     { }
     bool result{};
   };
@@ -899,7 +944,7 @@ template<class T> [[nodiscard]] constexpr auto& mut(const T& t) { return const_c
 
 template<class TLhs, class TRhs> struct eq {
   constexpr eq(const TLhs& lhs, const TRhs& rhs) : lhs{lhs}, rhs{rhs} { }
-  static_assert(type_traits::is_same_v<TLhs, TRhs>, "[ERROR] Comparision of different types is not allowed");
+  static_assert(type_traits::is_same_v<TLhs, TRhs>, "[ERROR] Comparision of different types is not allowed.");
   [[nodiscard]] constexpr explicit operator bool() const { return false; }
   const TLhs& lhs; const TRhs& rhs;
 };
@@ -913,7 +958,7 @@ template<class T> requires type_traits::is_floating_point_v<T> struct eq<T, T> {
   constexpr eq(const T& lhs, const T& rhs) : lhs{lhs}, rhs{rhs} { }
   constexpr friend auto operator<<(auto& os, const eq& expr) -> decltype(auto) { return (os << expr.lhs << " == " << expr.rhs); }
   [[nodiscard]] constexpr explicit operator bool() const {
-    static_assert(!type_traits::is_floating_point_v<T>, "[ERROR] Epsilon is required: expect((a == b)(epsilon))");
+    static_assert(!type_traits::is_floating_point_v<T>, "[ERROR] Epsilon is required - `expect((lhs == rhs)(epsilon))`. For example: `expect((4.2_f == sum(4.f, .2f))(.01f))`.");
     return {};
   }
   struct epsilon {
@@ -928,7 +973,7 @@ template<class T> requires type_traits::is_floating_point_v<T> struct eq<T, T> {
 template<class TLhs, class TRhs>
   requires requires(TLhs lhs, TRhs rhs) { lhs[0]; rhs[0]; lhs.size(); rhs.size(); }
 struct eq<TLhs, TRhs> {
-  static_assert(type_traits::is_same_v<decltype(utility::declval<TLhs>()[0]), decltype(utility::declval<TLhs>()[0])>, "[ERROR] Comparision of different underlying types is not allowed");
+  static_assert(type_traits::is_same_v<decltype(utility::declval<TLhs>()[0]), decltype(utility::declval<TLhs>()[0])>, "[ERROR] Comparision of different underlying types is not allowed.");
   constexpr eq(const TLhs& lhs, const TRhs& rhs) : lhs{lhs}, rhs{rhs}, result{
     [](const auto& lhs, const auto& rhs) {
       if (lhs.size() != rhs.size()) { return false; }
@@ -943,7 +988,7 @@ struct eq<TLhs, TRhs> {
 
 template<class TLhs, class TRhs> struct neq {
   constexpr neq(const TLhs& lhs, const TRhs& rhs) : lhs{lhs}, rhs{rhs} { }
-  static_assert(type_traits::is_same_v<TLhs, TRhs>, "[ERROR] Comparision of different types is not allowed");
+  static_assert(type_traits::is_same_v<TLhs, TRhs>, "[ERROR] Comparision of different types is not allowed.");
   [[nodiscard]] constexpr explicit operator bool() const { return false; }
   const TLhs& lhs; const TRhs& rhs;
 };
@@ -957,7 +1002,7 @@ template<class T> requires type_traits::is_floating_point_v<T> struct neq<T, T>
   constexpr neq(const T& lhs, const T& rhs) : lhs{lhs}, rhs{rhs} { }
   constexpr friend auto operator<<(auto& os, const neq& expr) -> decltype(auto) { return (os << expr.lhs << " != " << expr.rhs); }
   [[nodiscard]] constexpr explicit operator bool() const {
-    static_assert(!type_traits::is_floating_point_v<T>, "[ERROR] Epsilon is required: expect((a != b)(epsilon))");
+    static_assert(!type_traits::is_floating_point_v<T>, "[ERROR] Epsilon is required - `expect((lhs != rhs)(epsilon))`. For example: `expect((4.2_f != sum(4.f, .3f))(.01f))`.");
     return {};
   }
   struct epsilon {
@@ -972,7 +1017,7 @@ template<class T> requires type_traits::is_floating_point_v<T> struct neq<T, T>
 
 template<class TLhs, class TRhs> struct gt {
   constexpr gt(const TLhs& lhs, const TRhs& rhs) : lhs{lhs}, rhs{rhs} { }
-  static_assert(type_traits::is_same_v<TLhs, TRhs>, "[ERROR] Comparision of different types is not allowed");
+  static_assert(type_traits::is_same_v<TLhs, TRhs>, "[ERROR] Comparision of different types is not allowed.");
   [[nodiscard]] constexpr explicit operator bool() const { return false; }
   const TLhs& lhs; const TLhs& rhs;
 };
@@ -985,7 +1030,7 @@ template<class T> struct gt<T, T> {
 
 template<class TLhs, class TRhs> struct ge {
   constexpr ge(const TLhs& lhs, const TRhs& rhs) : lhs{lhs}, rhs{rhs} { }
-  static_assert(type_traits::is_same_v<TLhs, TRhs>, "[ERROR] Comparision of different types is not allowed");
+  static_assert(type_traits::is_same_v<TLhs, TRhs>, "[ERROR] Comparision of different types is not allowed.");
   [[nodiscard]] constexpr explicit operator bool() const { return false; }
   const TLhs& lhs; const TLhs& rhs;
 };
@@ -998,7 +1043,7 @@ template<class T> struct ge<T, T> {
 
 template<class TLhs, class TRhs> struct lt {
   constexpr lt(const TLhs& lhs, const TRhs& rhs) : lhs{lhs}, rhs{rhs} { }
-  static_assert(type_traits::is_same_v<TLhs, TRhs>, "[ERROR] Comparision of different types is not allowed");
+  static_assert(type_traits::is_same_v<TLhs, TRhs>, "[ERROR] Comparision of different types is not allowed.");
   [[nodiscard]] constexpr explicit operator bool() const { return false; }
   const TLhs& lhs; const TLhs& rhs;
 };
@@ -1011,7 +1056,7 @@ template<class T> struct lt<T, T> {
 
 template<class TLhs, class TRhs> struct le {
   constexpr le(const TLhs& lhs, const TRhs& rhs) : lhs{lhs}, rhs{rhs} { }
-  static_assert(type_traits::is_same_v<TLhs, TRhs>, "[ERROR] Comparision of different types is not allowed");
+  static_assert(type_traits::is_same_v<TLhs, TRhs>, "[ERROR] Comparision of different types is not allowed.");
   [[nodiscard]] constexpr explicit operator bool() const { return false; }
   const TLhs& lhs; const TLhs& rhs;
 };
@@ -1184,6 +1229,28 @@ static_assert(([] {
     static_assert('\0' == ut::utility::fixed_string{"foo"}[3]);
   }
 
+  // utility::match
+  {
+    static_assert(ut::utility::match("", ""));
+    static_assert(not ut::utility::match("", "foo"));
+    static_assert(ut::utility::match("*", ""));
+    static_assert(ut::utility::match("*", "foo"));
+    static_assert(ut::utility::match("*", "bar"));
+    static_assert(ut::utility::match("foo", "foo"));
+    static_assert(not ut::utility::match("foo", "bar"));
+    static_assert(not ut::utility::match("fo", "foo"));
+    static_assert(ut::utility::match("foo*", "foo"));
+    static_assert(ut::utility::match("foo*", "foo1"));
+    static_assert(ut::utility::match("foo*", "foo2"));
+    static_assert(ut::utility::match("foo*", "foo23"));
+    static_assert(ut::utility::match("foo?", "foo2"));
+    static_assert(ut::utility::match("foo?", "foo1"));
+    static_assert(ut::utility::match("foo??", "foo12"));
+    static_assert(ut::utility::match("foo?x", "foo1x"));
+    static_assert(ut::utility::match("foo?x", "foo2x"));
+    static_assert(not ut::utility::match("fo?xx", "fooxxx"));
+  }
+
   // ut::detail::get
   {
     static_assert(42 == ut::detail::get(42));
@@ -1361,5 +1428,3 @@ static_assert(([] {
   }
 }(), true));
 #endif // NTEST
-#endif // UT
-#endif // README