Atria

Local-first genomic interpretation for the desktop.

Watch the demo →

Atria is a privacy-first genomics workspace that analyzes genetic data entirely on the user's machine. The core stack is Rust, Tauri, and Polars, with a typed schema and compile-time module registry that keep the pipeline explicit as the product grows.

Navigating the Repo

atria/
├── crates/                  Rust workspace
│   ├── atria-schema/        Shared types (Finding, BodyZone, Severity) + generated TS bindings
│   ├── atria-core/          Module trait, registry, and pipeline orchestration
│   ├── atria-runtime/       Session engine — drives a full analysis run
│   ├── atria-db/            Bundle manifest validation and Polars table registry
│   ├── atria-io/            VCF ingest and variant normalization
│   ├── atria-py/            Typed Python bridge boundary (PyO3, sandboxed)
│   ├── mod-pgx/             Pharmacogenomics module
│   ├── mod-disease-risk/    Disease risk (BRCA, Lynch, etc.)
│   ├── mod-hla/             HLA typing and drug hypersensitivity
│   ├── mod-carrier/         Carrier screening
│   ├── mod-ancestry/        Ancestry composition
│   ├── mod-traits/          Trait predictions
│   └── mod-hello/           Scaffold/example module
├── apps/
│   ├── desktop/             Next.js + Tauri desktop application
│   │   ├── app/             Next.js pages (dashboard, body-map, processing)
│   │   ├── components/      UI components (body-map overlay, shell, etc.)
│   │   ├── lib/             Client utilities and type definitions
│   │   └── src-tauri/       Tauri Rust backend and config
│   └── web/                 Marketing website (Next.js)
├── demo/                    Demo VCF and validation data (see below)
├── atria-data/              Annotation bundle (gitignored — see Bundle section)
└── scripts/                 Bundle fetch and schema sync helpers

Building the Desktop App

Prerequisites

• Rust stable toolchain (pinned in rust-toolchain.toml)
• Node.js (v18+) and pnpm
• Tauri v2 system dependencies — see Tauri prerequisites

Install dependencies

pnpm install

Build and verify the Rust workspace

cargo build --workspace
cargo test  --workspace
cargo clippy --workspace --all-targets -- -D warnings

Run the Tauri desktop app (development)

pnpm --dir apps/desktop tauri:dev

This starts the Next.js dev server and launches the native Tauri window.

Build a release binary

pnpm --dir apps/desktop tauri:build

The packaged app appears under apps/desktop/src-tauri/target/release/bundle/.

Run the marketing website

pnpm web:dev        # dev server on :3100
pnpm web:build      # production build

Demo File

The file demo/atria_demo_trigger_dense.vcf is a synthetic VCF that has been artificially enriched with clinically significant variants across all seven modules (PGx, disease risk, HLA, carrier, ancestry, traits, and the hello scaffold). It exists so every module produces findings in a single test run without shipping a full-size genome file in the repository.

When the app launches, it presents a file picker. Select this file to test the app. The pipeline will produce findings for variants like CYP2C19 rs4244285 (PGx), BRCA2 rs80358695 (disease risk), and HLA-B*57:01 rs2395029 (HLA), among others.

demo/pipeline_validation_dense.json is the expected output used by the integration test suite in crates/atria-runtime/tests/dense_demo_e2e.rs.

Annotation Bundle

Some modules and tests require the local Parquet annotation bundle under atria-data/. This directory is gitignored because the bundle exceeds GitHub's file size limits. To fetch it:

./scripts/fetch-bundle.sh

Point ATRIA_BUNDLE_DIR at the bundle directory for bundle-backed tests:

ATRIA_BUNDLE_DIR="$(pwd)/atria-data" cargo test -p atria-db

If ATRIA_BUNDLE_DIR is unset, bundle-dependent tests are skipped automatically.

Python Bridge (atria-py)

The atria-py crate provides a typed boundary for modules that need Python (e.g. machine-learning models). It uses PyO3 behind an embedded-python feature flag with a sandboxed PyBridge trait.

The Python interpreter is not packaged into the app binary. This is intentional — bundling a full interpreter adds significant bloat. By default the NoopPyBridge is active: modules that call into Python still compile and run, but surface an honest "python disabled" finding. When the feature flag is enabled at build time, the interpreter and virtualenv must be placed in the Tauri resources directory.

# Default build — no Python, no interpreter
cargo build -p atria-py

# With embedded Python (requires bundled interpreter assets)
cargo build -p atria-py --features embedded-python

Useful Commands

# Sync generated TypeScript bindings from atria-schema into the desktop app
./scripts/sync-schema-bindings.sh

# Type-check the desktop app without building
pnpm desktop:typecheck

# Run only the desktop Next.js dev server (no Tauri window)
pnpm desktop:dev

Contributors

• Filip Rumenovski
• Mustafa Alithawi
• Teo Melnyczuk-Gould

License

Dual-licensed under MIT or Apache-2.0 at your option.