diff --git a/src/tools/info/sys_info.c b/src/tools/info/sys_info.c
index 6de08efe774..5fc0481a12a 100644
--- a/src/tools/info/sys_info.c
+++ b/src/tools/info/sys_info.c
@@ -1,5 +1,5 @@
 /**
-* Copyright (c) NVIDIA CORPORATION & AFFILIATES, 2001-2015. ALL RIGHTS RESERVED.
+* Copyright (c) NVIDIA CORPORATION & AFFILIATES, 2001-2026. ALL RIGHTS RESERVED.
 * Copyright (C) Shanghai Zhaoxin Semiconductor Co., Ltd. 2020. ALL RIGHTS RESERVED.
 * Copyright (C) Tactical Computing Labs, LLC. 2022. ALL RIGHTS RESERVED.
 * Copyright (C) Advanced Micro Devices, Inc. 2024. ALL RIGHTS RESERVED.
@@ -13,7 +13,8 @@
 
 #include "ucx_info.h"
 
-#include <ucs/sys/string.h>
+#include <ucs/debug/table.h>
+#include <ucs/debug/log.h>
 #include <ucs/sys/sys.h>
 #include <ucs/sys/math.h>
 #include <ucs/time/time.h>
@@ -61,129 +62,147 @@ static double measure_memcpy_bandwidth(size_t size)
     return result;
 }
 
-static void print_repeat_char(int ch, int count)
+/* Add an empty row used as vertical padding around content rows */
+static void print_sys_topo_add_padding(ucs_table_t *table)
 {
-    int i;
+    ucs_table_row_h row;
+    unsigned i;
 
-    for (i = 0; i < count; ++i) {
-        putchar(ch);
+    ucs_table_add_row(table, &row);
+
+    for (i = 0; i < table->config.n_cols; ++i) {
+        ucs_table_row_add_cell_empty(table, row, 1);
     }
 }
 
-static void print_row_separator(int column_width, int first_column_width,
-                                int num_columns, int fill_char,
-                                int separator_char)
+/* Add a header row of the shape "<label> | dev0 | dev1 | ...", surrounded
+ * by empty padding rows and followed by a separator. */
+static void print_sys_topo_add_devices_header(ucs_table_t *table,
+                                              const char *first_col_label,
+                                              unsigned num_devices)
 {
-    int i;
+    ucs_table_row_h row;
+    ucs_sys_device_t sys_dev;
 
-    printf("# %c", separator_char);
-    print_repeat_char(fill_char, first_column_width);
-    for (i = 0; i < num_columns; ++i) {
-        putchar(separator_char);
-        print_repeat_char(fill_char, column_width);
-    }
-    printf("%c\n", separator_char);
-}
+    print_sys_topo_add_padding(table);
 
-static void print_table_header(const char *title, const char *distance_unit,
-                               int column_width, int first_column_width,
-                               int num_columns)
-{
-    int column;
-
-    printf("#\n");
-    printf("# %s\n", title);
-    printf("#\n");
-    print_row_separator(column_width, first_column_width, num_columns, '-',
-                        '+');
-    print_row_separator(column_width, first_column_width, num_columns, ' ',
-                        '|');
-    printf("# |%*s ", first_column_width - 1, distance_unit);
-    for (column = 0; column < num_columns; ++column) {
-        printf("|%*s ", column_width - 1,
-               ucs_topo_sys_device_get_name((ucs_sys_device_t)column));
+    ucs_table_add_row(table, &row);
+    ucs_table_row_add_cell_fmt(table, row, 1, UCS_TABLE_ALIGN_RIGHT, "%s",
+                               first_col_label);
+
+    for (sys_dev = 0; sys_dev < num_devices; ++sys_dev) {
+        ucs_table_row_add_cell_fmt(table, row, 1, UCS_TABLE_ALIGN_RIGHT, "%s",
+                                   ucs_topo_sys_device_get_name(sys_dev));
     }
 
-    printf("|\n");
-    print_row_separator(column_width, first_column_width, num_columns, ' ',
-                        '|');
-    print_row_separator(column_width, first_column_width, num_columns, '-',
-                        '+');
+    print_sys_topo_add_padding(table);
+    ucs_table_add_separator(table);
 }
 
-static void print_sys_topo()
+static void print_sys_topo_distances(unsigned num_devices)
 {
-    const unsigned num_devices              = ucs_topo_num_devices();
-    static const int distance_width         = 10;
-    static const char *system_topo_title    = "System topology";
-    static const char *distance_unit        = "MB/s";
-    static const char *memory_latency_title = "NUMA memory latency";
-    static const char *numa_distance_unit   = "nsec";
+    ucs_table_config_t cfg = {
+        .n_cols       = 1 + num_devices,
+        .row_prefix   = "# ",
+        .equal_widths = 1,
+    };
     ucs_sys_device_t sys_dev1, sys_dev2;
     ucs_sys_dev_distance_t distance;
-    char distance_str[20];
-    ucs_status_t status;
-    int name_width;
+    ucs_status_t dist_status;
+    ucs_table_row_h row;
+    ucs_table_t table;
 
-    /* Get maximal width of device name */
-    name_width = 2 + strlen(distance_unit);
-    for (sys_dev1 = 0; sys_dev1 < num_devices; ++sys_dev1) {
-        name_width = ucs_max(
-                name_width, 2 + strlen(ucs_topo_sys_device_get_name(sys_dev1)));
-    }
+    printf("#\n# System topology\n#\n");
 
-    print_table_header(system_topo_title, distance_unit, distance_width,
-                       name_width, num_devices);
+    ucs_table_init(&table, &cfg);
+
+    print_sys_topo_add_devices_header(&table, "MB/s", num_devices);
 
-    /* Print table content */
     for (sys_dev1 = 0; sys_dev1 < num_devices; ++sys_dev1) {
-        print_row_separator(distance_width, name_width, num_devices, ' ', '|');
+        if (sys_dev1 > 0) {
+            ucs_table_add_separator(&table);
+        }
+
+        print_sys_topo_add_padding(&table);
+
+        ucs_table_add_row(&table, &row);
+        ucs_table_row_add_cell_fmt(&table, row, 1, UCS_TABLE_ALIGN_RIGHT, "%s",
+                                   ucs_topo_sys_device_get_name(sys_dev1));
 
-        printf("# |%*s ", name_width - 1,
-               ucs_topo_sys_device_get_name(sys_dev1));
         for (sys_dev2 = 0; sys_dev2 < num_devices; ++sys_dev2) {
             if (sys_dev1 == sys_dev2) {
                 /* Do not print distance of device to itself */
-                strncpy(distance_str, "-", sizeof(distance_str));
+                ucs_table_row_add_cell_fmt(&table, row, 1,
+                                           UCS_TABLE_ALIGN_CENTER, "%s", "-");
+                continue;
+            }
+
+            dist_status = ucs_topo_get_distance(sys_dev1, sys_dev2, &distance);
+            if (dist_status != UCS_OK) {
+                ucs_table_row_add_cell_fmt(&table, row, 1,
+                                           UCS_TABLE_ALIGN_RIGHT, "<%s>",
+                                           ucs_status_string(dist_status));
+            } else if (distance.bandwidth > UCS_PBYTE) {
+                ucs_table_row_add_cell_fmt(&table, row, 1,
+                                           UCS_TABLE_ALIGN_RIGHT, "%s", "inf");
             } else {
-                status = ucs_topo_get_distance(sys_dev1, sys_dev2, &distance);
-                if (status != UCS_OK) {
-                    ucs_snprintf_safe(distance_str, sizeof(distance_str),
-                                      "<%s>", ucs_status_string(status));
-                } else if (distance.bandwidth > UCS_PBYTE) {
-                    ucs_snprintf_safe(distance_str, sizeof(distance_str),
-                                      "inf");
-                } else {
-                    ucs_snprintf_safe(distance_str, sizeof(distance_str),
-                                      "%.1f", distance.bandwidth / UCS_MBYTE);
-                }
+                ucs_table_row_add_cell_fmt(&table, row, 1,
+                                           UCS_TABLE_ALIGN_RIGHT, "%.1f",
+                                           distance.bandwidth / UCS_MBYTE);
             }
-            printf("|%*s ", distance_width - 1, distance_str);
         }
-        printf("|\n");
 
-        print_row_separator(distance_width, name_width, num_devices, ' ', '|');
-        print_row_separator(distance_width, name_width, num_devices, '-', '+');
+        print_sys_topo_add_padding(&table);
     }
 
-    print_table_header(memory_latency_title, "device", distance_width,
-                       name_width, num_devices);
-    print_row_separator(distance_width, name_width, num_devices, ' ', '|');
+    ucs_table_print(&table);
+    ucs_table_cleanup(&table);
+}
+
+static void print_sys_topo_memory_latency(unsigned num_devices)
+{
+    ucs_table_config_t cfg = {
+        .n_cols       = 1 + num_devices,
+        .row_prefix   = "# ",
+        .equal_widths = 1,
+    };
+    ucs_sys_dev_distance_t distance;
+    ucs_sys_device_t sys_dev;
+    ucs_table_row_h row;
+    ucs_table_t table;
 
-    printf("# |%*s ", name_width - 1, numa_distance_unit);
-    printf("|");
-    for (sys_dev1 = 0; sys_dev1 < num_devices; ++sys_dev1) {
-        ucs_topo_get_memory_distance(sys_dev1, &distance);
-        ucs_snprintf_safe(distance_str, sizeof(distance_str), "%.1f",
-                          distance.latency * UCS_NSEC_PER_SEC);
-        printf("%*s |", distance_width - 1, distance_str);
+    printf("#\n# NUMA memory latency\n#\n");
+
+    ucs_table_init(&table, &cfg);
+
+    print_sys_topo_add_devices_header(&table, "device", num_devices);
+    print_sys_topo_add_padding(&table);
+
+    ucs_table_add_row(&table, &row);
+    ucs_table_row_add_cell_fmt(&table, row, 1, UCS_TABLE_ALIGN_RIGHT, "%s",
+                               "nsec");
+
+    for (sys_dev = 0; sys_dev < num_devices; ++sys_dev) {
+        ucs_topo_get_memory_distance(sys_dev, &distance);
+        ucs_table_row_add_cell_fmt(&table, row, 1, UCS_TABLE_ALIGN_RIGHT,
+                                   "%.1f", distance.latency * UCS_NSEC_PER_SEC);
     }
 
-    printf("\n");
-    print_row_separator(distance_width, name_width, num_devices, ' ', '|');
-    print_row_separator(distance_width, name_width, num_devices, '-', '+');
+    print_sys_topo_add_padding(&table);
+
+    ucs_table_print(&table);
 
     printf("# Memory latency is calculated according to the CPU affinity\n");
+
+    ucs_table_cleanup(&table);
+}
+
+static void print_sys_topo()
+{
+    const unsigned num_devices = ucs_topo_num_devices();
+
+    print_sys_topo_distances(num_devices);
+    print_sys_topo_memory_latency(num_devices);
 }
 
 static double measure_timer_accuracy()
diff --git a/src/ucp/proto/proto_common.c b/src/ucp/proto/proto_common.c
index 63b470d0b31..3568faa3cdf 100644
--- a/src/ucp/proto/proto_common.c
+++ b/src/ucp/proto/proto_common.c
@@ -789,7 +789,7 @@ void ucp_proto_request_select_error(ucp_request_t *req,
                                     size_t msg_length)
 {
     UCS_STRING_BUFFER_ONSTACK(sel_param_strb, UCP_PROTO_SELECT_PARAM_STR_MAX);
-    UCS_STRING_BUFFER_ONSTACK(proto_select_strb, UCP_PROTO_CONFIG_STR_MAX);
+    UCS_STRING_BUFFER_ONSTACK(proto_select_strb, UCS_ALLOCA_MAX_SIZE);
     ucp_ep_h ep = req->send.ep;
 
     ucp_proto_select_param_str(sel_param, ucp_operation_names, &sel_param_strb);
diff --git a/src/ucp/proto/proto_debug.c b/src/ucp/proto/proto_debug.c
index 570d8580bc7..5aeb03aa59f 100644
--- a/src/ucp/proto/proto_debug.c
+++ b/src/ucp/proto/proto_debug.c
@@ -14,6 +14,7 @@
 #include <ucp/am/ucp_am.inl>
 #include <ucp/rndv/proto_rndv.h>
 #include <ucs/arch/atomic.h>
+#include <ucs/debug/table.h>
 #include <fnmatch.h>
 #include <ctype.h>
 
@@ -62,16 +63,6 @@ struct ucp_proto_perf_node {
     };
 };
 
-/* Protocol information table */
-typedef struct {
-    char counter_str[32];
-    char range_str[32];
-    char desc[UCP_PROTO_DESC_STR_MAX];
-    char config[UCP_PROTO_CONFIG_STR_MAX];
-} ucp_proto_info_row_t;
-UCS_ARRAY_DECLARE_TYPE(ucp_proto_info_table_t, unsigned, ucp_proto_info_row_t);
-
-
 void ucp_proto_select_perf_str(const ucs_linear_func_t *perf, char *time_str,
                                size_t time_str_max, char *bw_str,
                                size_t bw_str_max)
@@ -142,20 +133,6 @@ ucp_proto_select_param_dump(ucp_worker_h worker,
                               operation_names, select_param_strb);
 }
 
-static void ucp_proto_table_row_separator(ucs_string_buffer_t *strb,
-                                          const int *column_width,
-                                          unsigned num_columns)
-{
-    unsigned i;
-
-    ucs_string_buffer_appendc(strb, '+', 1);
-    for (i = 0; i < num_columns; ++i) {
-        ucs_string_buffer_appendc(strb, '-', column_width[i] + 2);
-        ucs_string_buffer_appendc(strb, '+', 1);
-    }
-    ucs_string_buffer_appendc(strb, '\n', 1);
-}
-
 static int ucp_proto_debug_is_info_enabled(ucp_context_h context,
                                            const char *select_param_str,
                                            int show_used)
@@ -195,19 +172,6 @@ ucp_proto_select_elem_has_selections(const ucp_proto_select_elem_t *select_elem)
     return 0;
 }
 
-static void
-ucp_proto_selections_dump(ucp_worker_h worker,
-                          const ucp_proto_query_attr_t *proto_attr,
-                          const ucp_proto_select_param_t *select_param,
-                          char *counter_str, size_t size, int show_used)
-{
-    if (!show_used) {
-        *counter_str = '\0';
-        return;
-    }
-
-    ucs_snprintf_safe(counter_str, size, "%u  ", proto_attr->selections);
-}
 
 void
 ucp_proto_select_elem_info(ucp_worker_h worker,
@@ -219,12 +183,15 @@ ucp_proto_select_elem_info(ucp_worker_h worker,
 {
     UCS_STRING_BUFFER_ONSTACK(ep_cfg_strb, UCP_PROTO_CONFIG_STR_MAX);
     UCS_STRING_BUFFER_ONSTACK(sel_param_strb, UCP_PROTO_CONFIG_STR_MAX);
-    static const char *info_row_fmt = "| %s%*s | %-*s | %-*s |\n";
-    ucp_proto_info_table_t table;
-    int hdr_col_width[2], col_width[3];
+    const unsigned n_cols         = show_used ? 4 : 3;
+    const ucs_table_config_t tcfg = {
+        .n_cols = n_cols
+    };
     ucp_proto_query_attr_t proto_attr;
-    ucp_proto_info_row_t *row_elem;
+    ucs_table_t table;
+    ucs_table_row_h row;
     size_t range_start, range_end;
+    char range_str[32];
     int proto_valid;
 
     if (show_used && !ucp_proto_select_elem_has_selections(select_elem)) {
@@ -241,12 +208,38 @@ ucp_proto_select_elem_info(ucp_worker_h worker,
         return;
     }
 
-    /* Populate the table and column widths */
-    ucs_array_init_dynamic(&table);
-    col_width[0] = ucs_string_buffer_length(&ep_cfg_strb);
-    col_width[1] = 0;
-    col_width[2] = 0;
-    range_end    = -1;
+    ucs_table_init(&table, &tcfg);
+    /* Title: two full-width rows (ep_cfg, sel_param) without a separator
+     * between them, terminated by a single separator before the headers. */
+    ucs_table_add_row(&table, &row);
+    ucs_table_row_add_cell_fmt(&table, row, n_cols, UCS_TABLE_ALIGN_LEFT, "%s",
+                               ucs_string_buffer_cstr(&ep_cfg_strb));
+
+    ucs_table_add_row(&table, &row);
+    ucs_table_row_add_cell_fmt(&table, row, n_cols, UCS_TABLE_ALIGN_LEFT, "%s",
+                               ucs_string_buffer_cstr(&sel_param_strb));
+
+    ucs_table_add_separator(&table);
+
+    /* Column headers */
+    ucs_table_add_row(&table, &row);
+    if (show_used) {
+        ucs_table_row_add_cell_fmt(&table, row, 1, UCS_TABLE_ALIGN_CENTER,
+                                   "Count");
+    }
+
+    ucs_table_row_add_cell_fmt(&table, row, 1, UCS_TABLE_ALIGN_CENTER, "Range");
+
+    ucs_table_row_add_cell_fmt(&table, row, 1, UCS_TABLE_ALIGN_CENTER,
+                               "Description");
+
+    ucs_table_row_add_cell_fmt(&table, row, 1, UCS_TABLE_ALIGN_CENTER,
+                               "Config");
+
+    ucs_table_add_separator(&table);
+
+    /* One body row per valid protocol range. */
+    range_end = -1;
     do {
         range_start = range_end + 1;
         proto_valid = ucp_proto_select_elem_query(worker, select_elem,
@@ -257,56 +250,31 @@ ucp_proto_select_elem_info(ucp_worker_h worker,
             continue;
         }
 
-        row_elem = ucs_array_append(&table, break);
-
-        ucs_snprintf_safe(row_elem->desc, sizeof(row_elem->desc), "%s%s",
-                          proto_attr.is_estimation ? "(?) " : "",
-                          proto_attr.desc);
-        ucs_strncpy_safe(row_elem->config, proto_attr.config,
-                         sizeof(row_elem->config));
+        ucs_table_add_row(&table, &row);
+        ucs_memunits_range_str(range_start, range_end, range_str,
+                               sizeof(range_str));
+        if (show_used) {
+            ucs_table_row_add_cell_fmt(&table, row, 1, UCS_TABLE_ALIGN_RIGHT,
+                                       "%u", proto_attr.selections);
+        }
 
-        ucs_memunits_range_str(range_start, range_end, row_elem->range_str,
-                               sizeof(row_elem->range_str));
+        ucs_table_row_add_cell_fmt(&table, row, 1, UCS_TABLE_ALIGN_RIGHT, "%s",
+                                   range_str);
 
-        ucp_proto_selections_dump(worker, &proto_attr, select_param,
-                                  row_elem->counter_str,
-                                  sizeof(row_elem->counter_str), show_used);
+        ucs_table_row_add_cell_fmt(&table, row, 1, UCS_TABLE_ALIGN_LEFT, "%s%s",
+                                   proto_attr.is_estimation ? "(?) " : "",
+                                   proto_attr.desc);
 
-        col_width[0] = ucs_max(col_width[0], strlen(row_elem->counter_str) +
-                                             strlen(row_elem->range_str));
-        col_width[1] = ucs_max(col_width[1], strlen(row_elem->desc));
-        col_width[2] = ucs_max(col_width[2], strlen(row_elem->config));
+        ucs_table_row_add_cell_fmt(&table, row, 1, UCS_TABLE_ALIGN_LEFT, "%s",
+                                   proto_attr.config);
     } while (range_end != SIZE_MAX);
 
-    /* Resize column[1] to match longest row including header */
-    col_width[1] = ucs_max(col_width[1],
-                           (int)ucs_string_buffer_length(&sel_param_strb) -
-                                   col_width[2]);
-
-    /* Print header */
-    hdr_col_width[0] = col_width[0];
-    hdr_col_width[1] = col_width[1] + 3 + col_width[2];
-    ucp_proto_table_row_separator(strb, hdr_col_width, 2);
-    ucs_string_buffer_appendf(strb, "| %*s | %-*s |\n", hdr_col_width[0],
-                              ucs_string_buffer_cstr(&ep_cfg_strb),
-                              hdr_col_width[1],
-                              ucs_string_buffer_cstr(&sel_param_strb));
-
-    /* Print contents */
-    ucp_proto_table_row_separator(strb, col_width, 3);
-    ucs_array_for_each(row_elem, &table) {
-        ucs_string_buffer_appendf(strb, info_row_fmt, row_elem->counter_str,
-                                  col_width[0] - strlen(row_elem->counter_str),
-                                  row_elem->range_str, col_width[1],
-                                  row_elem->desc, col_width[2],
-                                  row_elem->config);
-    }
-    ucp_proto_table_row_separator(strb, col_width, 3);
+    ucs_table_render(&table, strb);
 
     /* remove trailing newline */
     ucs_string_buffer_rtrim(strb, "\n");
 
-    ucs_array_cleanup_dynamic(&table);
+    ucs_table_cleanup(&table);
 }
 
 void ucp_proto_select_info(ucp_worker_h worker,
@@ -318,11 +286,11 @@ void ucp_proto_select_info(ucp_worker_h worker,
     ucp_proto_select_elem_t select_elem;
     ucp_proto_select_key_t key;
 
-    kh_foreach(proto_select->hash, key.u64, select_elem,
-               ucp_proto_select_elem_info(worker, ep_cfg_index, rkey_cfg_index,
-                                          &key.param, &select_elem, show_all, 0,
-                                          strb);
-               ucs_string_buffer_appendf(strb, "\n"))
+    kh_foreach(proto_select->hash, key.u64, select_elem, {
+        ucp_proto_select_elem_info(worker, ep_cfg_index, rkey_cfg_index,
+                                   &key.param, &select_elem, show_all, 0, strb);
+        ucs_string_buffer_appendf(strb, "\n");
+    })
 }
 
 void ucp_proto_select_dump_short(const ucp_proto_select_short_t *select_short,
diff --git a/src/ucs/Makefile.am b/src/ucs/Makefile.am
index 96460695743..3e1ba98cd77 100644
--- a/src/ucs/Makefile.am
+++ b/src/ucs/Makefile.am
@@ -1,5 +1,5 @@
 #
-# Copyright (c) NVIDIA CORPORATION & AFFILIATES, 2001-2014. ALL RIGHTS RESERVED.
+# Copyright (c) NVIDIA CORPORATION & AFFILIATES, 2001-2026. ALL RIGHTS RESERVED.
 # Copyright (C) UT-Battelle, LLC. 2014-2017. ALL RIGHTS RESERVED.
 # Copyright (C) ARM Ltd. 2016-2017.  ALL RIGHTS RESERVED.
 # Copyright (C) Tactical Computing Labs, LLC. 2022. ALL RIGHTS RESERVED.
@@ -120,6 +120,7 @@ noinst_HEADERS = \
 	debug/debug_int.h \
 	debug/log.h \
 	debug/memtrack_int.h \
+	debug/table.h \
 	memory/numa.h \
 	memory/rcache_int.h \
 	memory/rcache.inl \
@@ -192,6 +193,7 @@ libucs_la_SOURCES = \
 	debug/assert.c \
 	debug/debug.c \
 	debug/log.c \
+	debug/table.c \
 	debug/memtrack.c \
 	memory/memory_type.c \
 	memory/memtype_cache.c \
diff --git a/src/ucs/debug/table.c b/src/ucs/debug/table.c
new file mode 100644
index 00000000000..98eaa7efa7d
--- /dev/null
+++ b/src/ucs/debug/table.c
@@ -0,0 +1,414 @@
+/**
+ * Copyright (c) NVIDIA CORPORATION & AFFILIATES, 2026. ALL RIGHTS RESERVED.
+ *
+ * See file LICENSE for terms.
+ */
+#include "ucs/type/status.h"
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "table.h"
+
+#include <ucs/debug/assert.h>
+#include <ucs/sys/compiler.h>
+#include <ucs/sys/math.h>
+#include <ucs/sys/string.h>
+#include <string.h>
+#include <ucs/debug/log.h>
+
+#define CHECK_STATUS(table) \
+    if (table->status != UCS_OK) { \
+        return; \
+    }
+
+void ucs_table_init(ucs_table_t *table, const ucs_table_config_t *config)
+{
+    table->status = UCS_OK;
+    table->config = *config;
+    ucs_array_init_dynamic(&table->entries);
+
+    if (config->n_cols == 0) {
+        ucs_error("table number of columns must be positive (n_cols: %u)",
+                  config->n_cols);
+        table->status = UCS_ERR_INVALID_PARAM;
+    }
+}
+
+void ucs_table_cleanup(ucs_table_t *table)
+{
+    ucs_table_entry_t *entry;
+    ucs_table_cell_t *cell;
+
+    ucs_array_for_each(entry, &table->entries) {
+        if (entry->kind != UCS_TABLE_ENTRY_ROW) {
+            continue;
+        }
+
+        ucs_array_for_each(cell, &entry->cells) {
+            ucs_string_buffer_cleanup(&cell->text);
+        }
+
+        ucs_array_cleanup_dynamic(&entry->cells);
+    }
+
+    ucs_array_cleanup_dynamic(&table->entries);
+}
+
+ucs_status_t ucs_table_get_status(const ucs_table_t *table)
+{
+    return table->status;
+}
+
+void ucs_table_add_separator(ucs_table_t *table)
+{
+    ucs_table_entry_t *entry;
+
+    CHECK_STATUS(table);
+
+    entry = ucs_array_append(
+            &table->entries,
+            ucs_error("failed to append table separator entry (entries: %u)",
+                      ucs_array_length(&table->entries)));
+    if (entry == NULL) {
+        table->status = UCS_ERR_NO_MEMORY;
+        return;
+    }
+
+    entry->kind = UCS_TABLE_ENTRY_SEPARATOR;
+}
+
+void ucs_table_add_row(ucs_table_t *table, ucs_table_row_h *row_p)
+{
+    ucs_table_entry_t *entry;
+    ucs_status_t status;
+
+    *row_p = 0;
+
+    CHECK_STATUS(table);
+
+    entry = ucs_array_append(
+            &table->entries,
+            ucs_error("failed to append table row entry (entries: %u)",
+                      ucs_array_length(&table->entries)));
+    if (entry == NULL) {
+        table->status = UCS_ERR_NO_MEMORY;
+        return;
+    }
+
+    entry->kind = UCS_TABLE_ENTRY_ROW;
+    ucs_array_init_dynamic(&entry->cells);
+
+    /* Pre-reserve so cell pointers stay stable across add_cell. */
+    status = ucs_array_reserve(&entry->cells, table->config.n_cols);
+    if (status != UCS_OK) {
+        ucs_error("failed to reserve %u cells for table row",
+                  table->config.n_cols);
+        table->status = status;
+        return;
+    }
+
+    *row_p = ucs_array_length(&table->entries) - 1;
+}
+
+static ucs_table_cells_t *
+ucs_table_row_cells(ucs_table_t *table, ucs_table_row_h row)
+{
+    ucs_table_entry_t *entry = &ucs_array_elem(&table->entries, row);
+
+    ucs_assert(entry->kind == UCS_TABLE_ENTRY_ROW);
+    return &entry->cells;
+}
+
+static ucs_status_t
+ucs_table_row_add_cell(ucs_table_t *table, ucs_table_row_h row,
+                       unsigned col_span, ucs_table_align_t align,
+                       ucs_table_cell_t **cell_p)
+{
+    ucs_table_cells_t *cells;
+    ucs_table_cell_t *cell;
+
+    cells = ucs_table_row_cells(table, row);
+
+    if (col_span == 0) {
+        ucs_error("table column span must be positive (col_span: %u)",
+                  col_span);
+        return UCS_ERR_INVALID_PARAM;
+    }
+
+    cell = ucs_array_append(
+            cells,
+            ucs_error("failed to add table cell (cells: %u, col_span: %u)",
+                      ucs_array_length(cells), col_span));
+    if (cell == NULL) {
+        return UCS_ERR_NO_MEMORY;
+    }
+
+    cell->col_span = col_span;
+    cell->align    = align;
+    ucs_string_buffer_init(&cell->text);
+
+    if (cell_p != NULL) {
+        *cell_p = cell;
+    }
+
+    return UCS_OK;
+}
+
+void ucs_table_row_add_cell_empty(ucs_table_t *table, ucs_table_row_h row,
+                                  unsigned col_span)
+{
+    CHECK_STATUS(table);
+
+    table->status = ucs_table_row_add_cell(table, row, col_span,
+                                           UCS_TABLE_ALIGN_LEFT, NULL);
+}
+
+void ucs_table_row_add_cell_fmt(ucs_table_t *table, ucs_table_row_h row,
+                                unsigned col_span, ucs_table_align_t align,
+                                const char *fmt, ...)
+{
+    ucs_table_cell_t *cell;
+    const char *cstr;
+    va_list ap;
+
+    CHECK_STATUS(table);
+
+    table->status = ucs_table_row_add_cell(table, row, col_span, align, &cell);
+
+    CHECK_STATUS(table);
+
+    va_start(ap, fmt);
+    ucs_string_buffer_vappendf(&cell->text, fmt, ap);
+    va_end(ap);
+
+    cstr = ucs_string_buffer_cstr(&cell->text);
+    if (strchr(cstr, '\n') != NULL) {
+        ucs_error("table cell content must not contain newline: '%s'", cstr);
+        table->status = UCS_ERR_INVALID_PARAM;
+    }
+}
+
+/* Calculate the total visible width of a cell spanning `col_span` columns. */
+static unsigned
+ucs_table_cell_character_width(ucs_table_t *table, const unsigned *widths,
+                               unsigned start, unsigned col_span)
+{
+    unsigned width = 0;
+    unsigned i;
+
+    ucs_assertv(col_span > 0, "column span must be positive (col_span: %u)",
+                col_span);
+    ucs_assertv(
+            start + col_span <= table->config.n_cols,
+            "column span exceeds number of columns (start: %u, col_span: %u)",
+            start, col_span);
+
+    for (i = 0; i < col_span; ++i) {
+        width += widths[start + i];
+    }
+
+    width += 3 * (col_span - 1);
+    return width;
+}
+
+static ucs_status_t
+ucs_table_compute_widths(ucs_table_t *table, unsigned *widths)
+{
+    ucs_table_entry_t *entry;
+    ucs_table_cell_t *cell;
+    unsigned i, col, content_len;
+    unsigned existing;
+
+    memset(widths, 0, table->config.n_cols * sizeof(*widths));
+
+    /* Pass 1: col_span == 1 cells. */
+    ucs_array_for_each(entry, &table->entries) {
+        if (entry->kind != UCS_TABLE_ENTRY_ROW) {
+            continue;
+        }
+
+        col = 0;
+        ucs_array_for_each(cell, &entry->cells) {
+            if (col + cell->col_span > table->config.n_cols) {
+                ucs_error("table row column span exceeds number of columns "
+                          "(col: %u, col_span: %u, n_cols: %u)",
+                          col, cell->col_span, table->config.n_cols);
+                return UCS_ERR_INVALID_PARAM;
+            }
+
+            if (cell->col_span == 1) {
+                content_len = ucs_string_buffer_length(&cell->text);
+                widths[col] = ucs_max(widths[col], content_len);
+            }
+
+            col += cell->col_span;
+        }
+    }
+
+    /* Pass 2: merged cells expand the rightmost spanned column. */
+    ucs_array_for_each(entry, &table->entries) {
+        if (entry->kind != UCS_TABLE_ENTRY_ROW) {
+            continue;
+        }
+
+        col = 0;
+        ucs_array_for_each(cell, &entry->cells) {
+            if (cell->col_span > 1) {
+                content_len = ucs_string_buffer_length(&cell->text);
+                existing = ucs_table_cell_character_width(table, widths, col,
+                                                          cell->col_span);
+
+                if (content_len > existing) {
+                    widths[col + cell->col_span - 1] += content_len - existing;
+                }
+            }
+
+            col += cell->col_span;
+        }
+    }
+
+    /* Equal-widths: widen every column to the max */
+    if (table->config.equal_widths) {
+        unsigned max_width = 0;
+        for (i = 0; i < table->config.n_cols; ++i) {
+            max_width = ucs_max(max_width, widths[i]);
+        }
+
+        for (i = 0; i < table->config.n_cols; ++i) {
+            widths[i] = max_width;
+        }
+    }
+
+    return UCS_OK;
+}
+
+/* Format a single cell at the given pixel width, branching on alignment. */
+static void ucs_table_render_cell(ucs_string_buffer_t *strb,
+                                  const ucs_table_cell_t *cell,
+                                  unsigned pixel_width)
+{
+    const char *cstr = ucs_string_buffer_cstr(&cell->text);
+    int content_len, pad, left_pad, right_pad;
+
+    switch (cell->align) {
+    case UCS_TABLE_ALIGN_LEFT:
+        ucs_string_buffer_appendf(strb, "| %-*s ", (int)pixel_width, cstr);
+        break;
+
+    case UCS_TABLE_ALIGN_RIGHT:
+        ucs_string_buffer_appendf(strb, "| %*s ", (int)pixel_width, cstr);
+        break;
+
+    case UCS_TABLE_ALIGN_CENTER:
+        content_len = (int)strlen(cstr);
+        pad         = ucs_max((int)pixel_width - content_len, 0);
+        left_pad    = pad / 2;
+        right_pad   = pad - left_pad;
+        ucs_string_buffer_appendf(strb, "| %*s%s%*s ", left_pad, "", cstr,
+                                  right_pad, "");
+        break;
+
+    default:
+        ucs_fatal("invalid cell alignment %d", cell->align);
+    }
+}
+
+static void
+ucs_table_append_row_prefix(const ucs_table_t *table, ucs_string_buffer_t *strb)
+{
+    if (table->config.row_prefix != NULL) {
+        ucs_string_buffer_appendf(strb, "%s", table->config.row_prefix);
+    }
+}
+
+/* Render one row. The closing "|" has no trailing newline. */
+static void ucs_table_render_cells(ucs_table_t *table, const unsigned *widths,
+                                   const ucs_table_cells_t *cells,
+                                   ucs_string_buffer_t *strb)
+{
+    const ucs_table_cell_t *cell;
+    unsigned col = 0;
+
+    ucs_table_append_row_prefix(table, strb);
+
+    ucs_array_for_each(cell, cells) {
+        ucs_table_render_cell(strb, cell,
+                              ucs_table_cell_character_width(table, widths, col,
+                                                             cell->col_span));
+        col += cell->col_span;
+    }
+    ucs_string_buffer_appendf(strb, "|");
+}
+
+static void ucs_table_render_separator(const ucs_table_t *table,
+                                       const unsigned *widths,
+                                       ucs_string_buffer_t *strb)
+{
+    unsigned i;
+
+    ucs_table_append_row_prefix(table, strb);
+
+    for (i = 0; i < table->config.n_cols; ++i) {
+        ucs_string_buffer_appendc(strb, '+', 1);
+        ucs_string_buffer_appendc(strb, '-', widths[i] + 2);
+    }
+
+    ucs_string_buffer_appendc(strb, '+', 1);
+    ucs_string_buffer_appendc(strb, '\n', 1);
+}
+
+void ucs_table_render(ucs_table_t *table, ucs_string_buffer_t *strb)
+{
+    const ucs_table_entry_t *entry;
+    ucs_status_t status;
+    unsigned *widths;
+    unsigned i;
+
+    CHECK_STATUS(table);
+
+    widths = ucs_alloca(table->config.n_cols * sizeof(*widths));
+    status = ucs_table_compute_widths(table, widths);
+    if (status != UCS_OK) {
+        table->status = status;
+        return;
+    }
+
+    /* Top frame */
+    ucs_table_render_separator(table, widths, strb);
+
+    /* Body rows and separators */
+    for (i = 0; i < ucs_array_length(&table->entries); ++i) {
+        entry = &ucs_array_elem(&table->entries, i);
+        switch (entry->kind) {
+        case UCS_TABLE_ENTRY_ROW:
+            ucs_table_render_cells(table, widths, &entry->cells, strb);
+            ucs_string_buffer_appendf(strb, "\n");
+            break;
+
+        case UCS_TABLE_ENTRY_SEPARATOR:
+            ucs_table_render_separator(table, widths, strb);
+            break;
+
+        default:
+            ucs_fatal("invalid table entry kind %d", entry->kind);
+        }
+    }
+
+    /* Bottom frame; skip when the last entry is already a separator. */
+    if (ucs_array_is_empty(&table->entries) ||
+        (ucs_array_last(&table->entries)->kind != UCS_TABLE_ENTRY_SEPARATOR)) {
+        ucs_table_render_separator(table, widths, strb);
+    }
+}
+
+void ucs_table_print(ucs_table_t *table)
+{
+    ucs_string_buffer_t strb = UCS_STRING_BUFFER_INITIALIZER;
+
+    CHECK_STATUS(table);
+
+    ucs_table_render(table, &strb);
+    printf("%s", ucs_string_buffer_cstr(&strb));
+    ucs_string_buffer_cleanup(&strb);
+}
diff --git a/src/ucs/debug/table.h b/src/ucs/debug/table.h
new file mode 100644
index 00000000000..0aecfc9da4f
--- /dev/null
+++ b/src/ucs/debug/table.h
@@ -0,0 +1,189 @@
+/**
+ * Copyright (c) NVIDIA CORPORATION & AFFILIATES, 2026. ALL RIGHTS RESERVED.
+ *
+ * See file LICENSE for terms.
+ */
+
+#ifndef UCS_TABLE_H_
+#define UCS_TABLE_H_
+
+#include <ucs/datastruct/array.h>
+#include <ucs/datastruct/string_buffer.h>
+#include <ucs/sys/compiler_def.h>
+#include <ucs/type/status.h>
+
+
+BEGIN_C_DECLS
+
+typedef unsigned ucs_table_row_h;
+
+
+/**
+ * Cell alignment, fixed at add-cell time.
+ */
+typedef enum {
+    UCS_TABLE_ALIGN_LEFT, /**< pad on the right */
+    UCS_TABLE_ALIGN_RIGHT, /**< pad on the left */
+    UCS_TABLE_ALIGN_CENTER /**< pad equally (right side gets the extra
+                                 when padding is odd) */
+} ucs_table_align_t;
+
+
+/** Cell entry (internal). */
+typedef struct {
+    unsigned            col_span; /**< body columns spanned */
+    ucs_table_align_t   align; /**< alignment selected at add-cell time */
+    ucs_string_buffer_t text; /**< cell content, owned by the table */
+} ucs_table_cell_t;
+
+
+typedef enum {
+    UCS_TABLE_ENTRY_ROW,
+    UCS_TABLE_ENTRY_SEPARATOR
+} ucs_table_entry_kind_t;
+
+
+/** Named dynamic array of cells used by a row entry. */
+UCS_ARRAY_DECLARE_TYPE(ucs_table_cells_t, unsigned, ucs_table_cell_t);
+
+
+/**
+ * Table entry: a row (vector of cells) or a separator. `cells` is only
+ * populated when `kind == UCS_TABLE_ENTRY_ROW`.
+ */
+typedef struct {
+    ucs_table_entry_kind_t kind;
+    ucs_table_cells_t      cells;
+} ucs_table_entry_t;
+
+
+UCS_ARRAY_DECLARE_TYPE(ucs_table_entries_t, unsigned, ucs_table_entry_t);
+
+
+/**
+ * Configuration for `ucs_table_init()`. Zero-initialize and set the fields
+ * you need; only `n_cols` is required.
+ */
+typedef struct {
+    /** Total number of columns; per-row cells' col_spans must sum to this. */
+    unsigned   n_cols;
+    /** Prepended to every rendered line */
+    const char *row_prefix;
+    /** When non-zero, render every column at the maximum computed width so
+     *  all columns are equal-width. */
+    int        equal_widths;
+} ucs_table_config_t;
+
+
+/**
+ * Buffered ASCII table.
+ */
+typedef struct {
+    ucs_table_config_t  config;
+    ucs_table_entries_t entries;
+    /** Sticky status; set on the first error. Once it is not UCS_OK,
+     *  every public API function becomes a silent no-op. */
+    ucs_status_t        status;
+} ucs_table_t;
+
+
+/**
+ * Initialize a buffered table.
+ *
+ * @param [out] table   Table to initialize.
+ * @param [in]  config  Configuration (non-NULL); see ucs_table_config_t.
+ *                      Copied into the table.
+ */
+void ucs_table_init(ucs_table_t *table, const ucs_table_config_t *config);
+
+
+/**
+ * Release the table.
+ *
+ * @param [in,out] table  Table to clean up.
+ */
+void ucs_table_cleanup(ucs_table_t *table);
+
+
+/**
+ * Get the current table status.
+ *
+ * The table fails silently: once an operation hits an error the status is set
+ * and every subsequent public API call becomes a no-op.
+ * This function can be used to query the status if needed.
+ *
+ * @param [in] table  Table to query.
+ *
+ * @return UCS_OK if no error has occurred, otherwise the first error code.
+ */
+ucs_status_t ucs_table_get_status(const ucs_table_t *table);
+
+
+/**
+ * Append a horizontal separator. The top and bottom frame separators are
+ * inserted automatically by ucs_table_render();
+ *
+ * @param [in,out] table  Table to append to.
+ */
+void ucs_table_add_separator(ucs_table_t *table);
+
+
+/**
+ * Begin a new row. Subsequent ucs_table_row_add_cell_*() calls populate it
+ * left-to-right; the sum of col_spans must equal n_cols. The returned
+ * handle is valid until the table is cleaned up;
+ *
+ * @param [in,out] table  Table to append to.
+ * @param [out]    row_p  Row handle for use with add-cell functions.
+ */
+void ucs_table_add_row(ucs_table_t *table, ucs_table_row_h *row_p);
+
+
+/**
+ * Add an empty cell.
+ *
+ * @param [in,out] table     Table that owns @a row.
+ * @param [in]     row       Row returned by ucs_table_add_row().
+ * @param [in]     col_span  Number of body columns to span.
+ */
+void ucs_table_row_add_cell_empty(ucs_table_t *table, ucs_table_row_h row,
+                                  unsigned col_span);
+
+
+/**
+ * Add a cell with printf-style content.
+ *
+ * @param [in,out] table     Table that owns @a row.
+ * @param [in]     row       Row returned by ucs_table_add_row().
+ * @param [in]     col_span  Number of body columns to span.
+ * @param [in]     align     Cell alignment.
+ * @param [in]     fmt       printf format string.
+ */
+void ucs_table_row_add_cell_fmt(ucs_table_t *table, ucs_table_row_h row,
+                                unsigned col_span, ucs_table_align_t align,
+                                const char *fmt, ...) UCS_F_PRINTF(5, 6);
+
+
+/**
+ * Render the table into @a strb. Recomputes column widths on every call,
+ * adapting to any rows or separators added since the previous render, and
+ * emits top frame + body rows/separators + bottom frame.
+ *
+ * @param [in,out] table  Table to render.
+ * @param [in,out] strb   Destination string buffer.
+ */
+void ucs_table_render(ucs_table_t *table, ucs_string_buffer_t *strb);
+
+
+/**
+ * Render the table directly to stdout.
+ *
+ * @param [in,out] table  Table to print.
+ *
+ */
+void ucs_table_print(ucs_table_t *table);
+
+
+END_C_DECLS
+
+#endif
diff --git a/test/gtest/Makefile.am b/test/gtest/Makefile.am
index 0c4b2af4baf..840c0c421f6 100644
--- a/test/gtest/Makefile.am
+++ b/test/gtest/Makefile.am
@@ -1,5 +1,5 @@
 #
-# Copyright (c) NVIDIA CORPORATION & AFFILIATES, 2001-2014. ALL RIGHTS RESERVED.
+# Copyright (c) NVIDIA CORPORATION & AFFILIATES, 2001-2026. ALL RIGHTS RESERVED.
 # Copyright (C) UT-Battelle, LLC. 2015. ALL RIGHTS RESERVED.
 # Copyright (C) The University of Tennessee and the University of Tennessee Research Foundation. 2016. ALL RIGHTS RESERVED.
 # Copyright (C) Los Alamos National Security, LLC. 2018 ALL RIGHTS RESERVED.
@@ -212,6 +212,7 @@ gtest_SOURCES = \
 	ucs/test_frag_list.cc \
 	ucs/test_type.cc \
 	ucs/test_log.cc \
+	ucs/test_table.cc \
 	ucs/test_iov.cc \
 	ucs/test_vfs.cc \
 	ucs/arch/test_x86_64.cc
diff --git a/test/gtest/ucs/test_table.cc b/test/gtest/ucs/test_table.cc
new file mode 100644
index 00000000000..4012e799369
--- /dev/null
+++ b/test/gtest/ucs/test_table.cc
@@ -0,0 +1,433 @@
+/**
+ * Copyright (c) NVIDIA CORPORATION & AFFILIATES, 2026. ALL RIGHTS RESERVED.
+ *
+ * See file LICENSE for terms.
+ */
+
+#include <common/test.h>
+extern "C" {
+#include <ucs/datastruct/string_buffer.h>
+#include <ucs/debug/table.h>
+}
+
+
+class test_table : public ucs::test {
+protected:
+    class table_t {
+    public:
+        explicit table_t(unsigned n_cols)
+        {
+            ucs_table_config_t cfg = {
+                .n_cols = n_cols
+            };
+            ucs_table_init(&m_table, &cfg);
+        }
+
+        explicit table_t(const ucs_table_config_t &cfg)
+        {
+            ucs_table_init(&m_table, &cfg);
+        }
+
+        ~table_t()
+        {
+            ucs_table_cleanup(&m_table);
+        }
+
+        ucs_table_t *get()
+        {
+            return &m_table;
+        }
+
+        ucs_table_row_h add_row()
+        {
+            ucs_table_row_h row;
+            ucs_table_add_row(&m_table, &row);
+            EXPECT_EQ(UCS_OK, ucs_table_get_status(&m_table));
+            return row;
+        }
+
+        std::string render()
+        {
+            ucs_string_buffer_t strb = UCS_STRING_BUFFER_INITIALIZER;
+            ucs_table_render(&m_table, &strb);
+            const std::string out(ucs_string_buffer_cstr(&strb));
+            ucs_string_buffer_cleanup(&strb);
+            return out;
+        }
+
+    private:
+        ucs_table_t m_table;
+    };
+};
+
+
+UCS_TEST_F(test_table, empty_table) {
+    table_t table(2);
+    EXPECT_EQ("+--+--+\n"
+              "+--+--+\n",
+              table.render());
+
+    EXPECT_EQ(UCS_OK, ucs_table_get_status(table.get()));
+}
+
+UCS_TEST_F(test_table, single_cell) {
+    table_t table(1);
+    auto row = table.add_row();
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_LEFT, "%s",
+                               "abc");
+
+    EXPECT_EQ("+-----+\n"
+              "| abc |\n"
+              "+-----+\n",
+              table.render());
+
+    EXPECT_EQ(UCS_OK, ucs_table_get_status(table.get()));
+}
+
+UCS_TEST_F(test_table, single_cell_empty) {
+    table_t table(1);
+    auto row = table.add_row();
+    ucs_table_row_add_cell_empty(table.get(), row, 1);
+
+    EXPECT_EQ("+--+\n"
+              "|  |\n"
+              "+--+\n",
+              table.render());
+
+    EXPECT_EQ(UCS_OK, ucs_table_get_status(table.get()));
+}
+
+
+UCS_TEST_F(test_table, wide_columns) {
+    table_t table(3);
+
+    auto row = table.add_row();
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_LEFT, "%s",
+                               "short");
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_CENTER,
+                               "%s", "even longer cell");
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_RIGHT, "%s",
+                               "wide third column");
+
+    row = table.add_row();
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_LEFT, "%s",
+                               "a much wider value");
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_CENTER,
+                               "%s", "x");
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_RIGHT, "%s",
+                               "y");
+
+    EXPECT_EQ("+--------------------+------------------+-------------------+\n"
+              "| short              | even longer cell | wide third column |\n"
+              "| a much wider value |        x         |                 y |\n"
+              "+--------------------+------------------+-------------------+\n",
+              table.render());
+
+    EXPECT_EQ(UCS_OK, ucs_table_get_status(table.get()));
+}
+
+UCS_TEST_F(test_table, separator) {
+    table_t table(2);
+
+    auto row = table.add_row();
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_LEFT, "%s",
+                               "a");
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_LEFT, "%s",
+                               "b");
+
+    ucs_table_add_separator(table.get());
+
+    row = table.add_row();
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_LEFT, "%s",
+                               "c");
+    ucs_table_row_add_cell_empty(table.get(), row, 1);
+
+    /* multiple separators */
+    ucs_table_add_separator(table.get());
+    ucs_table_add_separator(table.get());
+
+    row = table.add_row();
+    ucs_table_row_add_cell_empty(table.get(), row, 1);
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_LEFT, "%s",
+                               "d");
+
+    EXPECT_EQ("+---+---+\n"
+              "| a | b |\n"
+              "+---+---+\n"
+              "| c |   |\n"
+              "+---+---+\n"
+              "+---+---+\n"
+              "|   | d |\n"
+              "+---+---+\n",
+              table.render());
+
+    EXPECT_EQ(UCS_OK, ucs_table_get_status(table.get()));
+}
+
+UCS_TEST_F(test_table, trailing_separator_avoids_bottom_frame) {
+    table_t table(2);
+
+    auto row = table.add_row();
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_LEFT, "%s",
+                               "x");
+    ucs_table_row_add_cell_empty(table.get(), row, 1);
+
+    /* trailing separator, would prevent bottom frame from being rendered */
+    ucs_table_add_separator(table.get());
+
+    EXPECT_EQ("+---+--+\n"
+              "| x |  |\n"
+              "+---+--+\n",
+              table.render());
+
+    EXPECT_EQ(UCS_OK, ucs_table_get_status(table.get()));
+}
+
+
+UCS_TEST_F(test_table, col_span) {
+    table_t table(4);
+
+    auto row = table.add_row();
+    ucs_table_row_add_cell_fmt(table.get(), row, 4, UCS_TABLE_ALIGN_RIGHT,
+                               "col_span = %d", 4);
+
+    row = table.add_row();
+    ucs_table_row_add_cell_fmt(table.get(), row, 3, UCS_TABLE_ALIGN_LEFT,
+                               "col_span = %d", 3);
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_RIGHT, "%d",
+                               1);
+
+    row = table.add_row();
+    ucs_table_row_add_cell_fmt(table.get(), row, 2, UCS_TABLE_ALIGN_CENTER,
+                               "left_%d", 2);
+    ucs_table_row_add_cell_fmt(table.get(), row, 2, UCS_TABLE_ALIGN_CENTER,
+                               "right_%d", 2);
+
+    row = table.add_row();
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_LEFT, "%s",
+                               "abcd");
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_LEFT, "%s",
+                               "efgh");
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_LEFT, "%s",
+                               "ijkl");
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_LEFT, "%s",
+                               "mnop");
+
+    EXPECT_EQ("+------+------+------+------+\n"
+              "|              col_span = 4 |\n"
+              "| col_span = 3       |    1 |\n"
+              "|   left_2    |   right_2   |\n"
+              "| abcd | efgh | ijkl | mnop |\n"
+              "+------+------+------+------+\n",
+              table.render());
+
+    EXPECT_EQ(UCS_OK, ucs_table_get_status(table.get()));
+}
+
+UCS_TEST_F(test_table, col_span_sets_width) {
+    table_t table(2);
+
+    auto row = table.add_row();
+    ucs_table_row_add_cell_fmt(table.get(), row, 2, UCS_TABLE_ALIGN_LEFT, "%s",
+                               "this header is too wide");
+
+    row = table.add_row();
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_LEFT, "%s",
+                               "ab");
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_RIGHT, "%s",
+                               "cd");
+
+    EXPECT_EQ("+----+--------------------+\n"
+              "| this header is too wide |\n"
+              "| ab |                 cd |\n"
+              "+----+--------------------+\n",
+              table.render());
+
+    EXPECT_EQ(UCS_OK, ucs_table_get_status(table.get()));
+}
+
+UCS_TEST_F(test_table, cell_fmt) {
+    table_t table(2);
+
+    auto row = table.add_row();
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_CENTER,
+                               "%d %s..%s", 42, "lo", "hi");
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_LEFT,
+                               "%s=%u", "k", 7u);
+
+    row = table.add_row();
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_LEFT,
+                               "%.10f", 3.14159265358979);
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_RIGHT, "%s",
+                               "x");
+
+    EXPECT_EQ("+--------------+-----+\n"
+              "|  42 lo..hi   | k=7 |\n"
+              "| 3.1415926536 |   x |\n"
+              "+--------------+-----+\n",
+              table.render());
+
+    EXPECT_EQ(UCS_OK, ucs_table_get_status(table.get()));
+}
+
+UCS_TEST_F(test_table, row_prefix) {
+    ucs_table_config_t cfg = {
+        .n_cols     = 1,
+        .row_prefix = "# ",
+    };
+    table_t table(cfg);
+
+    auto row = table.add_row();
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_LEFT, "%s",
+                               "a");
+    ucs_table_add_separator(table.get());
+    row = table.add_row();
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_LEFT, "%s",
+                               "b");
+
+    EXPECT_EQ("# +---+\n"
+              "# | a |\n"
+              "# +---+\n"
+              "# | b |\n"
+              "# +---+\n",
+              table.render());
+    EXPECT_EQ(UCS_OK, ucs_table_get_status(table.get()));
+}
+
+
+UCS_TEST_F(test_table, equal_widths) {
+    ucs_table_config_t cfg = {
+        .n_cols       = 3,
+        .row_prefix   = NULL,
+        .equal_widths = 1,
+    };
+    table_t table(cfg);
+
+    auto row = table.add_row();
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_LEFT, "%s",
+                               "a");
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_LEFT, "%s",
+                               "longer");
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_LEFT, "%s",
+                               "xy");
+
+    EXPECT_EQ("+--------+--------+--------+\n"
+              "| a      | longer | xy     |\n"
+              "+--------+--------+--------+\n",
+              table.render());
+
+    EXPECT_EQ(UCS_OK, ucs_table_get_status(table.get()));
+}
+
+UCS_TEST_F(test_table, equal_widths_with_col_span) {
+    ucs_table_config_t cfg = {
+        .n_cols       = 2,
+        .row_prefix   = NULL,
+        .equal_widths = 1,
+    };
+    table_t table(cfg);
+
+    auto row = table.add_row();
+    ucs_table_row_add_cell_fmt(table.get(), row, 2, UCS_TABLE_ALIGN_LEFT, "%s",
+                               "this header is too wide");
+
+    row = table.add_row();
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_LEFT, "%s",
+                               "ab");
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_LEFT, "%s",
+                               "cd");
+
+    EXPECT_EQ("+--------------------+--------------------+\n"
+              "| this header is too wide                 |\n"
+              "| ab                 | cd                 |\n"
+              "+--------------------+--------------------+\n",
+              table.render());
+
+    EXPECT_EQ(UCS_OK, ucs_table_get_status(table.get()));
+}
+
+
+UCS_TEST_F(test_table, render_twice) {
+    /* Widths are recomputed on every render: a wider row added between
+     * renders must widen the columns on the second render. */
+    table_t table(2);
+    auto row = table.add_row();
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_LEFT, "%s",
+                               "a");
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_LEFT, "%s",
+                               "b");
+
+    EXPECT_EQ("+---+---+\n"
+              "| a | b |\n"
+              "+---+---+\n",
+              table.render());
+
+    row = table.add_row();
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_LEFT, "%s",
+                               "aaaaaaaaaaa");
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_LEFT, "%s",
+                               "bbbbbbbbbbb");
+
+    EXPECT_EQ("+-------------+-------------+\n"
+              "| a           | b           |\n"
+              "| aaaaaaaaaaa | bbbbbbbbbbb |\n"
+              "+-------------+-------------+\n",
+              table.render());
+
+    EXPECT_EQ(UCS_OK, ucs_table_get_status(table.get()));
+}
+
+UCS_TEST_F(test_table, invalid_n_cols) {
+    ucs_table_t table;
+    ucs_table_config_t cfg = {
+        .n_cols = 0
+    };
+    scoped_log_handler slh(hide_errors_logger);
+
+    ucs_table_init(&table, &cfg);
+    EXPECT_EQ(UCS_ERR_INVALID_PARAM, ucs_table_get_status(&table));
+}
+
+UCS_TEST_F(test_table, zero_col_span) {
+    table_t table(2);
+    auto row = table.add_row();
+    scoped_log_handler slh(hide_errors_logger);
+
+    ucs_table_row_add_cell_empty(table.get(), row, 0);
+    EXPECT_EQ(UCS_ERR_INVALID_PARAM, ucs_table_get_status(table.get()));
+}
+
+UCS_TEST_F(test_table, col_span_exceeds) {
+    table_t table(2);
+    auto row = table.add_row();
+
+    /* an oversized span is only detected at render time. */
+    ucs_table_row_add_cell_empty(table.get(), row, 3);
+    EXPECT_EQ(UCS_OK, ucs_table_get_status(table.get()));
+
+    {
+        scoped_log_handler slh(hide_errors_logger);
+        table.render();
+        EXPECT_EQ(UCS_ERR_INVALID_PARAM, ucs_table_get_status(table.get()));
+    }
+}
+
+UCS_TEST_F(test_table, cell_fmt_newline_1) {
+    table_t table(1);
+    auto row = table.add_row();
+    scoped_log_handler slh(hide_errors_logger);
+
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_LEFT,
+                               "a\nb");
+    EXPECT_EQ(UCS_ERR_INVALID_PARAM, ucs_table_get_status(table.get()));
+}
+
+UCS_TEST_F(test_table, cell_fmt_newline_2) {
+    table_t table(1);
+    auto row = table.add_row();
+    scoped_log_handler slh(hide_errors_logger);
+
+    ucs_table_row_add_cell_fmt(table.get(), row, 1, UCS_TABLE_ALIGN_LEFT,
+                               "a%sb", "\n");
+    EXPECT_EQ(UCS_ERR_INVALID_PARAM, ucs_table_get_status(table.get()));
+}