Views enable us to actually look at the data, not only filter, sort, organize and compute statistics on it (what tables are for 🔢). Let’s again consider the following data for self-proclaimed “10x” engineers on the team, which is the same data we used when explaining tables: Open in your console 
import unify
import random
from datetime import datetime, timedelta

num_employees = 20
ages = [
    random.randint(20, 50)
    for _ in range(num_employees)
]
catchphrases = random.choices(
    [
        "hello... friend",
        "hell no",
        "did you ask o3?",
        "will do it tomorrow",
        "ask the intern",
    ],
    k=num_employees,
)
last_logins = [
    (datetime.now() - timedelta(
        days=random.randint(0, 5)
    )).isoformat()
    for _ in range(num_employees)
]
open_task_progress = [
    {
        task: random.random()
        for task in random.sample(
            [
                "add NextJS loader",
                "SQL migration",
                "refactor life",
            ],
            random.randint(0, 3),
        )
    }
    for _ in range(num_employees)
]

for age, catchphrase, last_login, otp in zip(
    ages, catchphrases, last_logins, open_task_progress
):
    unify.log(
        age=age,
        how_10x=random.random()*10,
        catchphrase=catchphrase,
        last_login=last_login,
        open_task_progress=otp,
        will_to_live=random.choice([True, False]),
    )
A view tile must be paired with exactly one table, this can be done from the menu at the top.

​
Cell Selection

Every cell in a table is an atomic unit, which can be viewed independently. In it’s most basic form, the view pane acts as an expressive viewer for whatever cell(s) are selected in the table. These cells can be part of the same row, different rows, different columns, or any combination. In all cases, all of the data will be shown in the view pane.

​
Grouping

To avoid redundancy, every value that is shared across multiple cells is grouped in the view pane, with all the row numbers shown at the top.
This also makes it easy to quickly spot trends in the data.

​
View Modes

The view pane supports 3 different view modes:
  1. Markdown: All text is rendered as markdown.
  2. Plain Text: All text is rendered as plain text.
  3. Raw: The columns (incuding dicts, lists, numbers etc.) are rendered as a raw strings, with no formatting or nested structure.

​
Hiding Columns

Columns can be hidden by directly clicking the (-) icon which appears on hover, and also via the show / hide selector menu at the top. Column hiding in the view pane is totally independent from hidden columns in the table, making it easy to split the data across the two formats. For example, consider the following logged data: Open in your console 
import unify
import random

for question in ["what is 1 + 1?", "what is 2 + 2?", "what is 3 + 3?"]:
    student_answer = f"the answer is {random.randint(0, 6)}"
    correct_marks_to_award = int(int(student_answer[-1]) == int(eval(question[-4:-1])))
    awarded_marks = random.randint(0, 1)
    rationale = f"the student answered {student_answer} "
    "and I gave them {awarded_marks} marks because I'm not "
    "good at maths, and {awarded_marks} is my favourite number"
    diff = correct_marks_to_award - awarded_marks
    error = abs(diff)
    unify.log(
        question,
        student_answer=student_answer,
        available_marks=1,
        awarded_marks=awarded_marks,
        rationale=rationale,
        correct_marks_to_award=correct_marks_to_award,
        diff=diff,
        error=error,
    )
The most intuitive way to view this data is to show the numeric data in the table (with all the power of sorting, grouping, filtering etc.), and the text data in the view pane to look at the finer details (and benefit from all the view pane features).

​
Moving Columns

Columns can easily be moved in the view pane by selecting drag mode and then simply clicking and dragging them.

​
Split View

Sometimes it’s more convenient to view the data side-by-side, the split view makes this easy. You can toggle between one, two and three views.

​
Nesting

By default, the view pane will only expand one nest level at a time. The deeper contents of dicts and lists are lazily loaded as the nest is incrementally expanded. Pressing “Expand All Children” will expand all children recursively with one click, and “Collapse All Children” will do the inverse.

​
Diffs

The view pane supports very expressive diffs across cells. Let’s use a simple example for exploring the different diff features. Open in your console 
import unify
from datetime import datetime

unify.log(
    x=1,
    y=1.2,
    msg="hello friend",
    flag=True,
    appointment=datetime(2025, 3, 23, 10, 30).isoformat(),
    dct={"a": 1, "b": 2},
    lst=[1, 2, 3],
)
unify.log(
    x=2,
    y=1.2,
    msg="hey buddy",
    flag=True,
    appointment=datetime(2025, 2, 15, 11, 30).isoformat(),
    dct={"b": 2, "c": 3},
    lst=[4, 5, 6],
)
unify.log(
    x=3,
    y=1.3,
    msg="hello partner",
    flag=False,
    appointment=datetime(2025, 4, 11, 12, 30).isoformat(),
    dct={"a": 1, "b": 3, "c": 4},
    lst=[1, 2, 3, 4],
)

​
Strings

For string diffs, there are four modes:
  • None: No diff applied, just show contents grouped by value (as above).
  • Lines: Per line diffs.
  • Side-by-side: Per word diffs.
  • Characters: Per character diffs.

​
Numeric

Numeric value “diffs” support the four basic operators: -, +, * and /.

​
DateTime

Datetime diffs are presented as a relative difference in time, in the appropriate units (weeks, days, seconds, miliseconds etc.)

​
Structure Diffs

Aside from presenting the diffs for individual items, we can also see how the nested structure of dictionaries and lists change across logs. The same is also true for traces (more details below).

​
Base Log

All diffs are relative to the selected base log. This base log can easily be changed at the top of the view pane.

​
Traces

Last but not least, no observability tool would be complete without expressive traces. Traces enable you to get a complete view of nested function calls from your program 🔍

​
Trace Viewer

The trace viewer is shown on the left, which shows the nested structure of your entire trace. Each item in the trace is a span (unit of computation), and the children of each span are shown nested underneath. Each span shows the cumulative values for:
  • Cost: Can be manually specified during tracing for arbitrary programs. Unify’s LLM clients automatically populate this based on the cost of the LLM calls.
  • Tokens: Can be manually specified during tracing when integrating with other LLM providers. Unify’s LLM clients automatically populate this based on the tokens used in the LLM calls.
  • Runtime: Tracked automatically during tracing of the program.
Each span can be folded and unfolded, and the runtime of the base log can be viewed in the runtime viewer.

​
Span Viewer

The span viewer is shown on the right, and for each span, this shows:
  • Inputs: All inputs to the function call (if any).
  • Outputs: All outputs from the function call (if any).
  • Code: The source code of the function call.
  • Execution Time: The time taken to execute the function call.
  • Cost: The cost of the function call, including and excluding cached LLM calls which didn’t cost anything during the trace itself, but would if there was no cache to read from.
  • ID: The unique identifier for the span.
Some extra formatting is done for LLM calls which follow OpenAI’s standard: