# niiro

> Explainer videos generated from your frontend code. Push your code, niiro rebuilds your interface as a scene and narrates it with voice, chapters and captions. When your platform changes, the videos follow.

## Setup

1. Run init in your repo. It detects your framework and styling, proposes the paths to include and writes niiro.yml.
2. Check the allowlist. Only what stands in include leaves your machine. Everything else is invisible to niiro.
3. Push. The secret scan runs first and stops on a finding. Only files niiro does not have yet are uploaded.
4. Open the report in the portal. It names what niiro understood and proposes three videos.

### niiro.yml

```yaml
project: acme-web
include:
  - src/components/**
  - src/app/**
  - tailwind.config.ts
  - src/styles/**
exclude:
  - "**/*.test.*"
  - "**/__mocks__/**"
```

## Commands

- `niiro init`: Detects the stack, writes niiro.yml, stores the project token, offers a CI step.
- `niiro push`: Filters, scans for secrets, uploads the delta, reports which videos the change affects.
- `niiro status`: Last sync, number of stale videos, link into the portal.
- `niiro login`: Stores the token in the OS keychain. In CI use NIIRO_TOKEN instead.

## Always excluded

Even when a pattern would include them: environment files, node_modules, .git, lockfiles and binaries over 5 MB. The project token is write-only, it can create snapshots but never read code or anything derived from it.

## MCP server

It is a thin wrapper around the same commands, plus read access to the portal: video status, which videos a change affects, and creating a video request. There is no second code path, MCP calls the CLI logic as a library.

- `niiro_init`
- `niiro_push`
- `niiro_status`
- `niiro_affected_videos`
- `niiro_request_video`

```json
{
  "mcpServers": {
    "niiro": {
      "command": "npx",
      "args": ["-y", "niiro-mcp"],
      "env": { "NIIRO_TOKEN": "..." }
    }
  }
}
```

## Trust

- Your code is never built.
- Your code is never executed.
- Your code is never used to train models.
- Your code never leaves your tenant.

The allowlist lives in niiro.yml in your repo. What is not listed never leaves your machine. Environment files, node_modules, .git, lockfiles and binaries over 5 MB are excluded even if a pattern would match them. A secret scan runs before every upload and stops the push on a finding.

Files are stored encrypted, with a key per project. Blob addresses are derived with a tenant-specific salt, so identical files in different accounts never share a location. Deduplication happens inside one tenant, never across.

Every row and every job carries its tenant. Analysis and generation run in a sandbox with no code execution and no network access beyond our own APIs. Project tokens are write-only: they can create snapshots but cannot read code or anything derived from it.

## Start without talking to sales.

Estimated launch prices

- **Trial** 0 EUR no card: Analysis of your repo; Understood report; Short preview of your own app
- **Starter** 49 EUR per month: Around two videos; One language; Updates included
- **Growth** 199 EUR per month: Around eight videos; Three languages; Embed player; CI hook
- **Scale** 599 EUR per month: Around thirty videos; All languages; Priority in the queue

The monthly allowance expires, top-ups do not. Every expensive run shows an estimate first.

Analysis, report and preview are free. The first finished video is part of Starter.

## What people ask first.

### Which frameworks do you support?

Anything that renders to HTML and CSS. React, Next.js, Vue, Svelte and Angular are covered; monorepos are fine because you point at paths, not at a build.

### What happens to our code?

It is stored encrypted under a key of its own and read as reference material, never built and never executed. When you cancel, the data goes immediately and the key after seven days.

### How close is the replica?

Classes, spacing, colours and fonts are taken over literally from your code. The data in the scenes is invented and fits your domain.

### How long does the first video take?

Analysis and proposals within minutes. The first finished video goes through a human review before you see it.

### What does an update cost?

Only the modules that actually changed are regenerated, so an update is a fraction of the first run.

### Who owns the video?

You do. You can download, host and edit it, including after you cancel.

### Can we change the script?

Yes. The transcript is editable, and the voice is regenerated for the changed section only.

### What about screens behind a login?

They work, because niiro reads code instead of visiting your app. No credentials are needed.

## Languages

Every page exists under /en, /es and /de.