Keep research computation tidy.

Pointy Notebook keeps data, parameters, runs, outputs, and share links together.

Start from a project page, run an analysis, browse the results, and come back later to the same inputs, parameters, software details, and output files. The repository state and software environment stay attached too.

Try the live demo Read the docs Source on GitHub

Who Pointy is for

Pointy is for research teams that want computation to stay organized across projects, collaborators, and results.

For researchers

Run prepared analyses without starting from scratch.

  • Start with your data. Upload files, choose the relevant analysis, set the parameters for this run, and click Run.
  • The run stays organized. Pointy keeps the inputs, parameters, tool versions, status, and output files together in one place.
  • Results open in the browser. HTML reports, CSVs, plots, alignment files, FastQC summaries. Open them from the project page.
  • Share the exact result. Send your PI or collaborator a link. It opens the same read-only output view later, even after the current project has changed.

For research informaticians and core facilities

Put a browser form in front of the scripts and pipelines your team already uses.

  • Keep your existing tools. Wrap STAR, FastQC, BWA, Cell Ranger, R Markdown, or other Linux tools you can call from a Nix derivation.
  • Forms come from templates. For standard template fields, declare text fields, dropdowns, step references, upload inputs, and defaults; Pointy renders the researcher UI.
  • Prepared analyses stay reusable. Researchers can rerun prepared templates without asking you to set up each run, while you keep control of the templates, repository, and where Pointy runs.
  • Pinned workflow state. Pointy runs each step from a Git-pinned user repository and a Nix-built environment. The result stays tied to the commit, parameters, build inputs, and Nix output path.
Pointy project view showing steps grouped by type with Run controls, status dots, and an open output files browser

How it works

Each run gets one tidy place.

  1. An informatician sets up the analysis once.

    A template wraps a tool such as STAR, FastQC, BWA, Cell Ranger, an R Markdown report, or another Linux tool your team already runs, then defines the form fields researchers see: text inputs, dropdowns for choosing other steps, and file-upload fields.

  2. The researcher fills in the form.

    They choose input data, set parameters, and click Run. Pointy keeps the form values, status, and output files together on the project page.

    Step edit form with step-reference dropdowns and parameter fields
  3. Pointy runs it and shows the result.

    The form values are written to the user repository. Pointy starts the run and streams status updates to the browser. When the run finishes, the output is ready to browse: preview HTML reports inline, download files, or get a share link pinned to the exact commit.

    Output files browser showing an expanded folder with a previewed file

For example: upload FASTQ reads, run the lab's FastQC and alignment templates, preview the HTML report, download the BAM, and share a link pinned to the exact commit. The selected inputs, parameters, software details, and output files remain visible on the same project page.

Why Pointy

Pointy keeps the important pieces together.

Reproducibility

Pinned build context

Each result is tied to a Git commit and Nix build output, including the packages and system libraries in the dependency closure. Old results stay inspectable because the commit and build details remain attached to the run.

Deployment

Run it where the work belongs

Pointy can run on infrastructure you control when local data custody or institution-managed compute matters. Hosted deployments can run the same AGPLv3 notebook.

Sharing

Shareable result links

Share actions appear on shareable steps and successful output files or folders. A link opens the commit-pinned view it was created from, rather than the current version of the project.

Freedom

Free software you can keep

AGPLv3. The notebook code, documentation, and template model are public. Self-host it, fork it, patch it, or use managed hosting. The notebook remains free software.

Where Pointy fits

Pointy does not replace notebooks or workflow engines. It turns reusable analyses into tidy project pages with forms, live status, browsable outputs, and commit-pinned links.

Notebooks

Jupyter and Colab are for exploration

Pointy fits when an exploratory analysis becomes a repeated procedure.

Workflow engines

Nextflow and Snakemake are for pipelines

Pointy adds the project page: forms, live status, output browsing, and share links.

Galaxy

Galaxy is a full bioinformatics workbench

Pointy is smaller: your templates, Git state, and Nix builds.

Deployment

Run it yourself or use hosting

Hosting can change. The notebook stays AGPLv3.

Free software is the point

Researchers should be able to inspect, run, adapt, and host the tools their work depends on. A template built for one lab should be reusable by another lab.

That is why Pointy is AGPLv3. The notebook code and documentation stay public, and templates are meant to be shared.

If you build a template library for your lab's tools, publish it. The next graduate student in your field can start there instead of from scratch.

Get started

Start with the demo, then read the docs for templates and deployment.

Try the live demo

demo.pointy.cloud

A guided ten-lesson browser tutorial with sample data. The demo is browser-only, and the script step runs locally in the browser.

Read the docs

github.com/421anon/pointy/docs

The docs cover the UI, deployment, templates, and CLI inspection.

Self-host Pointy

github.com/421anon/pointy

Run Pointy with one Nix flake, one Linux server, and one Git repository for your team's templates and state. The docs cover the user repository, deployment pieces, and template setup.

Browse the standard library

github.com/421anon/pointy-stdlib

Reusable Nix helpers for building Pointy templates and browsable step outputs.