diff --git a/doc/changes/unreleased.md b/doc/changes/unreleased.md
index 4e2b159..5890e45 100644
--- a/doc/changes/unreleased.md
+++ b/doc/changes/unreleased.md
@@ -7,6 +7,7 @@ n/a
 
 ## Features / Enhancements
 
+ - #61: Added stacktrace-aware exceptions and assertions to v2
  - #32: Added clang tidy to v2
  - #36: Added developer guide for clang-tidy and clang-format
  - #38: Added Sonar Qube Public
diff --git a/udf-runner-cpp/v2/.bazelversion b/udf-runner-cpp/v2/.bazelversion
new file mode 100644
index 0000000..56b6be4
--- /dev/null
+++ b/udf-runner-cpp/v2/.bazelversion
@@ -0,0 +1 @@
+8.3.1
diff --git a/udf-runner-cpp/v2/BUILD.bazel b/udf-runner-cpp/v2/BUILD.bazel
index 4f2fbec..7a578f1 100644
--- a/udf-runner-cpp/v2/BUILD.bazel
+++ b/udf-runner-cpp/v2/BUILD.bazel
@@ -87,7 +87,7 @@ cc_library(
     name = "udf_protocol",
     srcs = ["udf_protocol.cc"],
     hdrs = ["udf_protocol.hpp", ":udf_protocol_generated"],
-    copts = ["-std=c++20"],
+    copts = ["-std=c++23"],
     # Do not depend on the ordinary runtime headers: the generated protocol
     # header must resolve all runtime includes through the isolated copy.
     deps = [":private_flatbuffers_runtime"],
@@ -96,7 +96,7 @@ cc_library(
 cc_test(
     name = "udf_protocol_test",
     srcs = ["udf_protocol_test.cc"],
-    copts = ["-std=c++20"],
+    copts = ["-std=c++23"],
     deps = [
         ":udf_protocol",
         "@googletest//:gtest_main",
@@ -106,7 +106,7 @@ cc_test(
 cc_binary(
     name = "udf_protocol_shared",
     srcs = ["udf_protocol.cc"],
-    copts = ["-std=c++20"],
+    copts = ["-std=c++23"],
     linkshared = 1,
     deps = [":udf_protocol"],
 )
@@ -114,7 +114,7 @@ cc_binary(
 cc_test(
     name = "udf_protocol_symbol_leak_test",
     srcs = ["nm_runner.hpp", "udf_protocol_symbol_leak_test.cc"],
-    copts = ["-std=c++20"],
+    copts = ["-std=c++23"],
     # The test inspects the built shared object with nm. data makes the
     # artifact available at runtime and args passes its runfiles path.
     data = [":udf_protocol_shared"],
@@ -126,7 +126,7 @@ cc_test(
 cc_test(
     name = "udf_protocol_static_symbol_leak_test",
     srcs = ["nm_runner.hpp", "udf_protocol_static_symbol_leak_test.cc"],
-    copts = ["-std=c++20"],
+    copts = ["-std=c++23"],
     # cc_library produces multiple artifacts, so the test receives all
     # locations and selects the static .a archive for nm inspection.
     data = [":udf_protocol"],
@@ -141,7 +141,7 @@ cc_test(
         "flatbuffers_header_order_test.cc",
         "flatbuffers_header_order_reverse.cc",
     ],
-    copts = ["-std=c++20"],
+    copts = ["-std=c++23"],
     # Compile both include orders against the ordinary runtime and the
     # isolated runtime to protect against header-guard and macro collisions.
     deps = [":udf_protocol", "@flatbuffers//:runtime_cc"],
@@ -165,7 +165,7 @@ cc_binary(
     srcs = ["arrow_c_data_demo.cc"],
     additional_linker_inputs = [":arrow_c_data_demo_exports"],
     copts = [
-        "-std=c++20",
+        "-std=c++23",
         "-fvisibility=hidden",
         "-fvisibility-inlines-hidden",
     ],
@@ -181,7 +181,7 @@ cc_binary(
 cc_test(
     name = "arrow_core_test",
     srcs = ["arrow_core_test.cc"],
-    copts = ["-std=c++20"],
+    copts = ["-std=c++23"],
     deps = [
         ":arrow_core",
         "@googletest//:gtest_main",
@@ -191,7 +191,7 @@ cc_test(
 cc_test(
     name = "arrow_c_data_demo_test",
     srcs = ["arrow_c_data_demo_test.cc"],
-    copts = ["-std=c++20"],
+    copts = ["-std=c++23"],
     data = [":libarrow_c_data_demo.so"],
     args = ["$(location :libarrow_c_data_demo.so)"],
     linkopts = ["-ldl"],
@@ -203,6 +203,7 @@ cc_library(
     name = "json_schema",
     hdrs = ["include/exasol/udf/v2/json_schema.hpp"],
     includes = ["include"],
+    copts = ["-std=c++23"],
     deps = ["@v2_json_schema_validator//:json_schema_validator"],
 )
 
@@ -210,7 +211,7 @@ cc_test(
     name = "json_schema_validation_test",
     srcs = ["json_schema_validation_test.cc"],
     data = ["//json_schema:all_schemas"],
-    copts = ["-std=c++17"],
+    copts = ["-std=c++23"],
     deps = [
         ":json_schema",
         "@googletest//:gtest_main",
@@ -220,7 +221,7 @@ cc_test(
 cc_test(
     name = "json_schema_symbol_leak_test",
     srcs = ["json_schema_symbol_leak_test.cc"],
-    copts = ["-std=c++17"],
+    copts = ["-std=c++23"],
     linkopts = ["-ldl"],
     target_compatible_with = ["@platforms//os:linux"],
     deps = [":json_schema"],
@@ -231,7 +232,7 @@ cc_fuzz_test(
     srcs = ["frame_fuzz_test.cc"],
     corpus = glob(["fuzz/corpus/frame/**"]),
     dicts = ["fuzz/frame.dict"],
-    copts = ["-std=c++20"],
+    copts = ["-std=c++23"],
     deps = [":udf_protocol"],
     tags = ["fuzz-test"],
 )
@@ -241,7 +242,7 @@ cc_fuzz_test(
     srcs = ["call_metadata_fuzz_test.cc", "test_utils/json_schema_fuzzing.hpp"],
     corpus = glob(["fuzz/corpus/call_metadata/**"]),
     dicts = ["fuzz/json.dict"],
-    copts = ["-std=c++17"],
+    copts = ["-std=c++23"],
     data = ["//json_schema:all_schemas"],
     deps = [":json_schema"],
     tags = ["fuzz-test"],
@@ -252,7 +253,7 @@ cc_fuzz_test(
     srcs = ["connection_information_fuzz_test.cc", "test_utils/json_schema_fuzzing.hpp"],
     corpus = glob(["fuzz/corpus/connection_information/**"]),
     dicts = ["fuzz/json.dict"],
-    copts = ["-std=c++17"],
+    copts = ["-std=c++23"],
     data = ["//json_schema:all_schemas"],
     deps = [":json_schema"],
     tags = ["fuzz-test"],
@@ -263,7 +264,7 @@ cc_fuzz_test(
     srcs = ["export_specification_fuzz_test.cc", "test_utils/json_schema_fuzzing.hpp"],
     corpus = glob(["fuzz/corpus/export_specification/**"]),
     dicts = ["fuzz/json.dict"],
-    copts = ["-std=c++17"],
+    copts = ["-std=c++23"],
     data = ["//json_schema:all_schemas"],
     deps = [":json_schema"],
     tags = ["fuzz-test"],
@@ -274,7 +275,7 @@ cc_fuzz_test(
     srcs = ["import_specification_fuzz_test.cc", "test_utils/json_schema_fuzzing.hpp"],
     corpus = glob(["fuzz/corpus/import_specification/**"]),
     dicts = ["fuzz/json.dict"],
-    copts = ["-std=c++17"],
+    copts = ["-std=c++23"],
     data = ["//json_schema:all_schemas"],
     deps = [":json_schema"],
     tags = ["fuzz-test"],
@@ -287,6 +288,7 @@ cc_library(
         "include/exasol/udf/v2/spsc_queue.hpp",
     ],
     includes = ["include"],
+    copts = ["-std=c++23"],
     deps = [
         "@v2_concurrentqueue//:concurrentqueue",
         "@v2_readerwriterqueue//:readerwriterqueue",
@@ -296,7 +298,7 @@ cc_library(
 cc_test(
     name = "moodycamel_queues_test",
     srcs = ["moodycamel_queues_test.cc"],
-    copts = ["-std=c++20"],
+    copts = ["-std=c++23"],
     deps = [
         ":moodycamel_queues",
         "@googletest//:gtest_main",
@@ -306,7 +308,7 @@ cc_test(
 cc_binary(
     name = "moodycamel_queues_shared",
     srcs = ["moodycamel_queues_shared.cc"],
-    copts = ["-std=c++20"],
+    copts = ["-std=c++23"],
     linkshared = 1,
     deps = [":moodycamel_queues"],
 )
@@ -314,7 +316,7 @@ cc_binary(
 cc_test(
     name = "moodycamel_symbol_leak_test",
     srcs = ["moodycamel_symbol_leak_test.cc"],
-    copts = ["-std=c++20"],
+    copts = ["-std=c++23"],
     data = [":moodycamel_queues_shared"],
     args = ["$(location :moodycamel_queues_shared)"],
     target_compatible_with = ["@platforms//os:linux"],
@@ -326,13 +328,14 @@ cc_library(
     srcs = ["event_fd.cc"],
     hdrs = ["include/exasol/udf/v2/event_fd.hpp"],
     includes = ["include"],
+    copts = ["-std=c++23"],
     target_compatible_with = ["@platforms//os:linux"],
 )
 
 cc_test(
     name = "event_fd_test",
     srcs = ["event_fd_test.cc"],
-    copts = ["-std=c++20"],
+    copts = ["-std=c++23"],
     deps = [
         ":event_fd",
         "@googletest//:gtest_main",
@@ -344,6 +347,7 @@ cc_library(
     name = "waitable_queue",
     hdrs = ["include/exasol/udf/v2/waitable_queue.hpp"],
     includes = ["include"],
+    copts = ["-std=c++23"],
     deps = [
         ":event_fd",
         ":moodycamel_queues",
@@ -354,7 +358,7 @@ cc_library(
 cc_test(
     name = "waitable_queue_test",
     srcs = ["waitable_queue_test.cc"],
-    copts = ["-std=c++20"],
+    copts = ["-std=c++23"],
     deps = [
         ":waitable_queue",
         "@googletest//:gtest",
@@ -366,7 +370,7 @@ cc_test(
 cc_test(
     name = "waitable_queue_integration_test",
     srcs = ["waitable_queue_integration_test.cc"],
-    copts = ["-std=c++20"],
+    copts = ["-std=c++23"],
     deps = [
         ":waitable_queue",
         "@googletest//:gtest_main",
@@ -378,7 +382,7 @@ cc_test(
 cc_binary(
     name = "waitable_queue_benchmark",
     srcs = ["waitable_queue_benchmark.cc"],
-    copts = ["-std=c++20"],
+    copts = ["-std=c++23"],
     deps = [
         ":waitable_queue",
         "@google_benchmark//:benchmark_main",
@@ -390,8 +394,32 @@ cc_fuzz_test(
     name = "queue_fuzz_test",
     srcs = ["queue_fuzz_test.cc"],
     corpus = glob(["fuzz/corpus/queue/**"]),
-    copts = ["-std=c++20"],
+    copts = ["-std=c++23"],
     deps = [":waitable_queue"],
     tags = ["fuzz-test"],
     target_compatible_with = ["@platforms//os:linux"],
 )
+
+cc_library(
+    name = "exception",
+    srcs = ["assert.cc"],
+    hdrs = [
+        "include/exasol/udf/v2/assert.hpp",
+        "include/exasol/udf/v2/exception.hpp",
+    ],
+    includes = ["include"],
+    copts = ["-std=c++23"],
+    linkopts = ["-lstdc++exp"],
+)
+
+cc_test(
+    name = "exception_test",
+    srcs = ["exception_test.cc"],
+    copts = ["-std=c++23"],
+    tags = ["no-mull"],
+    deps = [
+        ":exception",
+        "@googletest//:gtest_main",
+    ],
+    target_compatible_with = ["@platforms//os:linux"],
+)
diff --git a/udf-runner-cpp/v2/assert.cc b/udf-runner-cpp/v2/assert.cc
new file mode 100644
index 0000000..29bac21
--- /dev/null
+++ b/udf-runner-cpp/v2/assert.cc
@@ -0,0 +1,54 @@
+#include <exasol/udf/v2/assert.hpp>
+
+#include <cstdio>
+#include <sstream>
+#include <utility>
+
+namespace exasol::udf::v2::detail
+{
+
+std::string format_stacktrace_entry(const std::size_t frame_number,
+                                    const std::string_view description,
+                                    const std::string_view source_file,
+                                    const std::uint_least32_t source_line)
+{
+    std::ostringstream output;
+    output << "  #" << frame_number << ' ' << description;
+    if (!source_file.empty())
+    {
+        output << " (" << source_file << ':' << source_line << ')';
+    }
+    output << '\n';
+    return output.str();
+}
+
+std::string format_assertion_failure(const Exception& error)
+{
+    std::ostringstream output;
+    output << error.location().file_name() << ':' << error.location().line() << ':'
+           << error.location().function_name() << ": " << error.what() << '\n';
+    std::size_t frame_number = 0;
+    for (const auto& frame : error.stacktrace())
+    {
+        output << format_stacktrace_entry(frame_number, frame.description(), frame.source_file(),
+                                          frame.source_line());
+        ++frame_number;
+    }
+    return output.str();
+}
+
+[[noreturn]] void assertion_failure(const char* expression,
+                                    std::source_location location,
+                                    const AssertionTerminator& terminator)
+{
+    std::ostringstream message;
+    message << "Assertion failed: " << expression;
+    const Exception error(message.str(), location);
+    const std::string output = format_assertion_failure(error);
+    static_cast<void>(std::fwrite(output.data(), sizeof(char), output.size(), stderr));
+    std::fflush(stderr);
+    terminator();
+    std::unreachable();
+}
+
+} // namespace exasol::udf::v2::detail
diff --git a/udf-runner-cpp/v2/exception_test.cc b/udf-runner-cpp/v2/exception_test.cc
new file mode 100644
index 0000000..6572b6f
--- /dev/null
+++ b/udf-runner-cpp/v2/exception_test.cc
@@ -0,0 +1,122 @@
+#include <array>
+#include <cstdlib>
+#include <exception>
+#include <string>
+#include <string_view>
+#include <source_location>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include <exasol/udf/v2/assert.hpp>
+#include <exasol/udf/v2/exception.hpp>
+#include <gtest/gtest.h>
+
+namespace
+{
+
+struct AssertionTermination : std::exception
+{
+};
+
+[[noreturn]] void throw_assertion_termination()
+{
+    throw AssertionTermination{};
+}
+
+[[noreturn]] void trigger_assertion()
+{
+    EXASOL_UDF_ASSERT(false);
+}
+
+void trigger_successful_assertion()
+{
+    EXASOL_UDF_ASSERT(true);
+}
+
+TEST(ExceptionTest, CapturesMessageLocationAndStacktrace)
+{
+    const exasol::udf::v2::Exception error("example message");
+    EXPECT_STREQ(error.what(), "example message");
+    EXPECT_FALSE(error.stacktrace().empty());
+    EXPECT_EQ(error.location().file_name(), std::string_view(__FILE__));
+}
+
+TEST(ExceptionTest, FormatsStacktraceEntries)
+{
+    EXPECT_EQ(exasol::udf::v2::detail::format_stacktrace_entry(1, "function", "", 0),
+              "  #1 function\n");
+    EXPECT_EQ(exasol::udf::v2::detail::format_stacktrace_entry(2, "function", "source.cc", 42),
+              "  #2 function (source.cc:42)\n");
+}
+
+TEST(ExceptionTest, FormatsAssertionFailure)
+{
+    const exasol::udf::v2::Exception error("example message");
+    const std::string output = exasol::udf::v2::detail::format_assertion_failure(error);
+
+    EXPECT_NE(output.find(__FILE__), std::string::npos);
+    EXPECT_NE(output.find("example message"), std::string::npos);
+    EXPECT_NE(output.find("  #0 "), std::string::npos);
+}
+
+TEST(ExceptionTest, ReportsAssertionFailureBeforeTermination)
+{
+    bool termination_called = false;
+    const auto terminator   = [&termination_called] {
+        termination_called = true;
+        throw_assertion_termination();
+    };
+
+    EXPECT_THROW(exasol::udf::v2::detail::assertion_failure(
+                     "false", std::source_location::current(), terminator),
+                 AssertionTermination);
+    EXPECT_TRUE(termination_called);
+}
+
+TEST(ExceptionTest, AssertionSucceedsForTrueCondition)
+{
+    EXPECT_NO_THROW(trigger_successful_assertion());
+}
+
+TEST(ExceptionTest, AssertionAbortsAndPrintsStacktrace)
+{
+    std::array<int, 2> output_pipe{};
+    const int pipe_result = ::pipe(output_pipe.data());
+    ASSERT_EQ(pipe_result, 0);
+
+    const pid_t child = ::fork();
+    ASSERT_GE(child, 0);
+    if (child == 0)
+    {
+        ::close(output_pipe[0]);
+        if (const int dup2_result = ::dup2(output_pipe[1], STDERR_FILENO); dup2_result < 0)
+        {
+            std::_Exit(EXIT_FAILURE);
+        }
+        ::close(output_pipe[1]);
+        trigger_assertion();
+        std::_Exit(EXIT_FAILURE);
+    }
+
+    ::close(output_pipe[1]);
+    std::string output;
+    std::array<char, 4096> buffer{};
+    ssize_t bytes_read = 0;
+    while ((bytes_read = ::read(output_pipe[0], buffer.data(), buffer.size())) > 0)
+    {
+        output.append(buffer.data(), static_cast<std::size_t>(bytes_read));
+    }
+    ::close(output_pipe[0]);
+    ASSERT_GE(bytes_read, 0);
+
+    int status              = 0;
+    const pid_t wait_result = ::waitpid(child, &status, 0);
+    ASSERT_EQ(wait_result, child);
+    ASSERT_TRUE(WIFSIGNALED(status));
+    EXPECT_EQ(WTERMSIG(status), SIGABRT);
+    EXPECT_FALSE(output.empty());
+    EXPECT_NE(output.find("Assertion failed: false"), std::string::npos);
+    EXPECT_NE(output.find("trigger_assertion"), std::string::npos);
+}
+
+} // namespace
diff --git a/udf-runner-cpp/v2/include/exasol/udf/v2/assert.hpp b/udf-runner-cpp/v2/include/exasol/udf/v2/assert.hpp
new file mode 100644
index 0000000..e9cb5fd
--- /dev/null
+++ b/udf-runner-cpp/v2/include/exasol/udf/v2/assert.hpp
@@ -0,0 +1,42 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <functional>
+#include <source_location>
+#include <string>
+#include <string_view>
+
+#include <exasol/udf/v2/exception.hpp>
+
+namespace exasol::udf::v2::detail
+{
+
+[[nodiscard]] std::string format_stacktrace_entry(const std::size_t frame_number,
+                                                  const std::string_view description,
+                                                  const std::string_view source_file,
+                                                  const std::uint_least32_t source_line);
+
+[[nodiscard]] std::string format_assertion_failure(const Exception& error);
+
+using AssertionTerminator = std::function<void()>;
+
+// Keep production termination injectable so tests can replace abort with a throwing callback.
+[[noreturn]] void assertion_failure(
+    const char* expression,
+    std::source_location location,
+    const AssertionTerminator& terminator = [] { std::abort(); });
+
+} // namespace exasol::udf::v2::detail
+
+// Wrap the macro in one statement so it is safe to use in if/else control flow.
+#define EXASOL_UDF_ASSERT(condition)                                                       \
+    do                                                                                     \
+    {                                                                                      \
+        if (!(condition))                                                                  \
+        {                                                                                  \
+            ::exasol::udf::v2::detail::assertion_failure(#condition,                       \
+                                                         std::source_location::current()); \
+        }                                                                                  \
+    } while (false)
diff --git a/udf-runner-cpp/v2/include/exasol/udf/v2/exception.hpp b/udf-runner-cpp/v2/include/exasol/udf/v2/exception.hpp
new file mode 100644
index 0000000..98a75c9
--- /dev/null
+++ b/udf-runner-cpp/v2/include/exasol/udf/v2/exception.hpp
@@ -0,0 +1,44 @@
+#pragma once
+
+#include <exception>
+#include <source_location>
+#include <stacktrace>
+#include <string>
+#include <utility>
+
+namespace exasol::udf::v2
+{
+
+class Exception : public std::exception
+{
+public:
+    explicit Exception(std::string message,
+                       std::source_location location = std::source_location::current())
+        : message_(std::move(message)),
+          location_(location),
+          stacktrace_(std::stacktrace::current(1))
+    {
+    }
+
+    [[nodiscard]] const char* what() const noexcept override
+    {
+        return message_.c_str();
+    }
+
+    [[nodiscard]] const std::source_location& location() const noexcept
+    {
+        return location_;
+    }
+
+    [[nodiscard]] const std::stacktrace& stacktrace() const noexcept
+    {
+        return stacktrace_;
+    }
+
+private:
+    std::string message_;
+    std::source_location location_;
+    std::stacktrace stacktrace_;
+};
+
+} // namespace exasol::udf::v2
diff --git a/udf-runner-cpp/v2/sonar-project.properties b/udf-runner-cpp/v2/sonar-project.properties
index df7e160..ca17499 100644
--- a/udf-runner-cpp/v2/sonar-project.properties
+++ b/udf-runner-cpp/v2/sonar-project.properties
@@ -5,7 +5,10 @@ sonar.projectKey=udf-runner-cpp
 # in v2 while excluding vendored third-party sources.
 sonar.sources=.
 sonar.exclusions=third_party/**,bazel-*/**
-sonar.coverage.exclusions=**/*_test.cc,**/json_schema_fuzzing.hpp,**/event_fd.cc,**/arrow_c_data_demo.cc
+# Assertion termination includes intentionally untestable abort paths and
+# compiler-generated exception branches. Keep the files in Sonar analysis,
+# but exclude them from the coverage gate.
+sonar.coverage.exclusions=**/*_test.cc,**/json_schema_fuzzing.hpp,**/event_fd.cc,**/arrow_c_data_demo.cc,assert.cc,include/exasol/udf/v2/assert.hpp
 
 # Bazel's SonarQube coverage generator writes this generic coverage report.
 sonar.coverageReportPaths=bazel-out/_coverage/_coverage_report.dat