TableWriter for Go

tablewriter is a Go library for generating rich text-based tables with support for multiple output formats, including ASCII, Unicode, Markdown, HTML, and colorized terminals. Perfect for CLI tools, logs, and web applications.

Key Features

• Multi-format rendering: ASCII, Unicode, Markdown, HTML, ANSI-colored
• Advanced styling: Cell merging, alignment, padding, borders
• Flexible input: CSV, structs, slices, or streaming data
• High performance: Minimal allocations, buffer reuse
• Modern features: Generics support, hierarchical merging, real-time streaming

---

Installation

Legacy Version (v0.0.5)

For use with legacy applications:

go get github.com/olekukonko/[email protected]

Latest Version

The latest stable version

go get github.com/olekukonko/[email protected]

Warning: Version v1.0.0 contains missing functionality and should not be used.

Version Guidance

• Legacy: Use v0.0.5 (stable)
• New Features: Use @latest (includes generics, super fast streaming APIs)
• Legacy Docs: See README_LEGACY.md

---

Why TableWriter?

• CLI Ready: Instant compatibility with terminal outputs
• Database Friendly: Native support for sql.Null* types
• Secure: Auto-escaping for HTML/Markdown
• Extensible: Custom renderers and formatters

---

Quick Example

package main

import (
	"github.com/olekukonko/tablewriter"
	"os"
)

func main() {
	data := [][]string{
		{"Package", "Version", "Status"},
		{"tablewriter", "v0.0.5", "legacy"},
		{"tablewriter", "v1.1.5", "latest"},
	}

	table := tablewriter.NewWriter(os.Stdout)
	table.Header(data[0])
	table.Bulk(data[1:])
	table.Render()
}

Output:

┌─────────────┬─────────┬────────┐
│   PACKAGE   │ VERSION │ STATUS │
├─────────────┼─────────┼────────┤
│ tablewriter │ v0.0.5  │ legacy │
│ tablewriter │ v1.1.5  │ latest │
└─────────────┴─────────┴────────┘

Detailed Usage

Create a table with NewTable or NewWriter, configure it using options or a Config struct, add data with Append or Bulk, and render to an io.Writer. Use renderers like Blueprint (ASCII), HTML, Markdown, Colorized, or Ocean (streaming).

Here's how the API primitives map to the generated ASCII table:

API Call                                  ASCII Table Component
--------                                  ---------------------

table.Header([]string{"NAME", "AGE"})     ┌──────┬─────┐  ← Borders.Top
                                          │ NAME │ AGE │  ← Header row
                                          ├──────┼─────┤  ← Lines.ShowTop (header separator)

table.Append([]string{"Alice", "25"})     │ Alice│ 25  │  ← Data row
                                          ├──────┼─────┤  ← Separators.BetweenRows

table.Append([]string{"Bob", "30"})       │ Bob  │ 30  │  ← Data row
                                          ├──────┼─────┤  ← Lines.ShowBottom (footer separator)

table.Footer([]string{"Total", "2"})      │ Total│ 2   │  ← Footer row
                                          └──────┴─────┘  ← Borders.Bottom

The core components include:

• Renderer - Implements the core interface for converting table data into output formats. Available renderers include Blueprint (ASCII), HTML, Markdown, Colorized (ASCII with color), Ocean (streaming ASCII), and SVG.

• Config - The root configuration struct that controls all table behavior and appearance

  • Behavior - Controls high-level rendering behaviors including auto-hiding empty columns, trimming row whitespace, header/footer visibility, and compact mode for optimized merged cell calculations
  • CellConfig - The comprehensive configuration template used for table sections (header, row, footer). Combines formatting, padding, alignment, filtering, callbacks, and width constraints with global and per-column control
  • StreamConfig - Configuration for streaming mode including enable/disable state and strict column validation

• Rendition - Defines how a renderer formats tables and contains the complete visual styling configuration

  • Borders - Control the outer frame visibility (top, bottom, left, right edges) of the table
  • Lines - Control horizontal boundary lines (above/below headers, above footers) that separate different table sections
  • Separators - Control the visibility of separators between rows and between columns within the table content
  • Symbols - Define the characters used for drawing table borders, corners, and junctions

These components can be configured with various tablewriter.With*() functional options when creating a new table.

Examples

Basic Examples

1. Simple Tables

Create a basic table with headers and rows.

default

package main

import (
	"fmt"
	"github.com/olekukonko/tablewriter"
	"os"
)

type Age int

func (a Age) String() string {
	return fmt.Sprintf("%d yrs", a)
}

func main() {
	data := [][]any{
		{"Alice", Age(25), "New York"},
		{"Bob", Age(30), "Boston"},
	}

	table := tablewriter.NewTable(os.Stdout)
	table.Header("Name", "Age", "City")
	table.Bulk(data)
	table.Render()
}

Output:

┌───────┬────────┬──────────┐
│ NAME  │  AGE   │   CITY   │
├───────┼────────┼──────────┤
│ Alice │ 25 yrs │ New York │
│ Bob   │ 30 yrs │ Boston   │
└───────┴────────┴──────────┘

This is the beginning of the README. Read the rest at the original. Read the full README ↗