Pointy Notebook

Welcome to the Pointy Notebook home page.

Pointy helps research teams keep computational work tidy by storing inputs, software, notes, and results together so any run can be inspected in its wholeness. It achieves a very high level of computational reproducibility by utilizing the Nix sandbox, an isolated computational environment where the only way to enter data and software is by precise advance declaration. If you do the in vitro part of an experiment in a sterile environment, you should do the same with the in silico part, shouldn't you? Moreover: with Pointy, all workflows are ordinary code. You plug in a Git repository and Pointy writes versioned workflow definitions in it. Conveniently, you can edit the same repository using your own tooling: VS Code, LLM agents, etc. It's really that simple. And tidy. Marketing called and they told me to keep using the word "tidy".

The sections below describe three ways to work with Pointy: through the web UI, with an LLM working directly in the repository, or through a custom UI built against the backend API.

The Pointy Web project list with named projects, step counts, last-run timestamps, and status indicators.

Pointy's web UI supports established analyses from project setup through sharing results. A project collects predefined analyses (called templates), uploaded files, analysis steps with their parameters (called steps), run states and outputs. Results can be viewed in the browser as text, HTML, images, CSV, or TSV, compared with other outputs, and shared using a read-only link to the exact project state.

→ Managing Projects · Building Workflows · Execution and Data Management

Use your own LLM workflow

The Pointy data store is a Git repository, and step definitions are represented as plan Nix attribute sets, which are directly analogous to JSON objects. An LLM can work on the analysis directly: creating steps, connecting inputs and dependencies, adding scripts, and changing how results are combined.

For example, a bioinformatician processing a 96-well plate can define the per-sample analysis once, use an LLM to create and configure the steps for all 96 samples, and add an aggregate step that produces plate-level statistics and charts. This avoids creating and connecting dozens of runs by hand. The resulting workflow remains inspectable, versioned code in the repository rather than state held inside an LLM session.

→ Setting Up the User Repository · CLI Reference

Build your own UI against the backend API

Some analyses require a dedicated workflow wizard that validates an experimental design, collects task-specific parameters, presents conditional questions, or generates a large set of connected analysis steps.

Pointy provides the platform behind such a UI. Templates defined in the user repository describe the available step types and their inputs. The backend API exposes the creation and configuration of those steps, runs them, reports their status, and exposes their outputs. Pointy catalogs every run and keeps its outputs connected to the inputs, parameters, and upstream steps that produced them, so the custom UI can focus on the task-specific workflow instead of run storage, output management, and data lineage.

→ Backend API Reference · Template Type Reference

How it works

Define. A repository template declares the step type, inputs, options, dependencies, and build.
Present. Pointy exposes that definition as typed web forms and backend API configuration.
Organize. A project groups uploads and dependent steps into one workflow.
Run. Pointy evaluates the pinned repository state and submits the configured build on controlled infrastructure.
Inspect. Reports, text, tables, images, logs, and generated files remain attached to the step.
Share. A read-only URL pins the project and selected output to a Git commit.

A Pointy link can open a read-only project at a specific Git commit, deep-link to an output file or folder, and highlight selected lines in a text result. The recipient sees the state that was shared, not whatever happens to be current later.

Read the sharing documentation →

Deployment and storage

The frontend and backend are self-hosted. A NixOS module is provided for easy setup; check out Pointy's source code. Workflow state lives in the Git-backed user repository, and Nix defines and evaluates builds. Runs can be submitted through Slurm when configured, and outputs are kept reachable through registered garbage-collector roots.

→ Architecture & Configuration

Documentation

Using Pointy Web

Managing Projects: create, open, hide, reorder, and delete projects.
Building Workflows (Steps): add steps, connect them, reuse them across projects, and organize them.
Execution and Data Management: run steps, upload files, inspect outputs, compare files, work with source files, and create share links.

Defining and hosting workflows

Architecture & Configuration: runtime architecture, backend config, sync behaviour, status streaming, and GC roots.
Setting Up the User Repository: create the Git-backed flake that defines templates, steps, projects, and source files.
Type Reference: reference for the template option types exposed by pointy-stdlib.
CLI Reference: inspect and build flake outputs directly with nix.

Using the backend API

Backend API Reference: explore endpoints or build a client from the generated OpenAPI reference.

Pointy is distributed under the GNU AGPL v3.

Browse, share, and run simple analyses through the web UI