Join the early access list

Chrome extension

Ask YouTube anything.

Prism is a chat side panel for YouTube that turns intent — a mood, an era, a curriculum, a duration — into a short, hand-picked batch of videos. Every pick explains itself, and the taste model behind it lives only on your machine.

Try asking: “”

Join the early access list See how it works
  • Free · no account
  • Nothing leaves your browser
  • Chrome 116+
take me back to 2008 listen to a podcast teach myself programming surprise me
Manifest V3 · v1.0.0 Chrome 116 or newer Zero dependencies 278 automated tests passing No account · no cloud Talks only to youtube.com

The gap

YouTube search finds videos. It doesn't find what you meant.

The search box is built for finding a video you already have in mind — not for expressing an intention. That gap is exactly where Prism lives.

“I want something long to listen to while I cook.”
That's a duration + format + mood request — not a keyword.
“I remember loving documentaries around 2007.”
YouTube barely lets you search by era — and its results never say why anything was chosen.
“I want to get better at photography, in order, from the beginning.”
That's a curriculum, not a search.
“Show me something outside my usual bubble.”
The opposite of what the recommendation engine is optimized for.

Prism closes the gap between intent and results — while keeping every bit of the personalization on your own machine.

How it works

You speak. The engine plans, listens, and delivers.

Under the hood is a five-module engine inspired by BeezGroup's 2022 design document: a “thought” enters, gets parsed, becomes a plan, searches YouTube with your own session, and returns as a small deck of cards — each with a one-line reason why it's there.

flowchart LR A(["Device signal"]) --> B["Neural Synthesizer"] B --> C["Requests file"] C --> D["Sleeping-Zero"] D --> E["Responses file"] E --> F(["Delivered — chat · cards · chips"]) classDef engine fill:#7C5CFF22,stroke:#8B6EF3,stroke-width:1.4px; classDef file fill:#D9553F1C,stroke:#D96A54,stroke-width:1.4px; classDef plain fill:transparent,stroke:#B9B3C6,stroke-width:1px; class B,D engine; class C,E file; class A,F plain;
The path of a single “thought” — from sensor, through the engine, to the screen.
  1. 1

    Listening

    “Recording this in your request file…”

    Your ask is saved as a chat message and a memory. Detected topics get a small weight bump before any search happens.

  2. 2

    Reading

    “Parsing what you actually want…”

    The intent parser extracts topic, format, era, duration, level, mood — and the kind of ask. Small talk stops here; no search needed.

  3. 3

    Synthesizing

    “Searching YouTube and collecting candidates…”

    The planner builds the query and YouTube's own filter flags. The background fetches the results page with your session and parses the embedded JSON.

  4. 4

    Processing

    “Scoring candidates against your interests…”

    Every candidate is scored — affinity, era, duration, format, level, your taste dials, views — then filtered for things you've already seen.

  5. 5

    Delivering

    “Writing the best matches to your response file…”

    Top six (max two per channel) become cards with ≈year chips and why-lines, plus alternative angles and follow-up chips.

An illustration of the side panel. Titles are illustrative; the mechanics are real.

Twelve example asks — and what Prism does about them
You typeWhat Prism does
listen to a podcastLong-form search (20+ minutes, YouTube's own filter); podcasts automatically imply “long” unless you say otherwise.
watch a video from the 2000sSorts by the era's most-viewed (“classics”), then post-filters by estimated decade; cards show an ≈2009 chip. If too few strict matches exist, it relaxes gracefully and says so.
learn a business skillTutorial-leaning query; practical 10–30 minute picks.
teach myself programmingBeginner-weighted query; front-loads “from scratch” content; offers a Go deeper follow-up and can become a learning path.
90s hip hopEra (“90s”) + topic text (“hip hop”) both parse.
cooking videos under 10 minutesDuration filter (“under 10 minutes”).
a relaxing lofi mix to studyMood detection (“calm & focus”) and music-leaning formats.
a video from the 2000sWorks with no topic at all — the era alone plots a plan.
more like #1Riffs on the #1 pick of your latest batch — excluding it, using its title and channel as the seed.
take me back to 2008The Time Machine — a keepsake deck across every one of your chosen areas.
latest on my topicsA fresh, date-sorted deck covering each area you picked during onboarding.
make me a learning path for pythonBuilds an ordered, time-budgeted curriculum — beginner → tutorial → advanced.

Every batch also brings different angles (a modern take, a gentler on-ramp, an adjacent topic), follow-up chips, and a why-line under each pick drawn from your own graph.

Research

Rooted in BeezGroup's Sleeping-Zero architecture.

Prism is a working implementation of “Sleeping-Zero Algorithm and Neural Synthesizer” — a design document published by BeezGroup in 2022. The names sound futuristic; the implementation is honest, deterministic, and yours to audit.

Design document conceptWhat it meansWhere it lives in Prism
Neural Synthesizer Collects “thoughts” from the device (apps used, likes, location…) and decides the delivery format for answers. lib/synth.js + content/collector.js — gathers watch sessions, searches and likes (only with consent); decides how each answer is delivered (text, cards, alternatives, chips).
Requests file Everything collected from the device, stored in one place. prism.requests in Chrome's local storage — an append-only queue of signals.
Sleeping-Zero An engine that wakes on an autonomous interval, reads the requests file, processes it, and writes results to the responses file. lib/sleeping-zero.js + a Chrome alarm firing every 1 minute: intent parsing, search planning, scoring, era filtering, alternatives, and the background For You batch.
Responses file Everything the engine produced, ready for delivery. prism.responses — the batches of picks and the For You deck.
User account / data dictionary The per-user database of thoughts, memories, possible responses, outcomes and consent. prism.profile — the interest graph (topics, channels, eras, formats), the memory log, shown-history, feedback, saved items, and the consent record (lib/interest.js).
Cognitive benchmark + consent A first-run study of the user; the user decides whether to keep or delete it. The calibration onboarding, the “You” tab benchmark report, and one-click erase.

Special powers

Six things YouTube's search box simply can't do.

These are the features that make people keep Prism open: era surfing, curricula, answers from inside videos, and a player that never makes you leave the conversation.

“take me back to 2008”

Instead of one topic, Prism builds a keepsake deck: one or two videos from each of your chosen areas, tuned for that year — searched with era filters and view sorting, years estimated and kept to the closest matches, every card labeled with its topic (“2008 History”).

  • Type any year from 2005 to today — or tap 2007 / 2012 / 2018.
  • Every card carries an ≈year chip — never pretending to be exact.
  • “Latest on my topics” is the mirror image: the freshest video from each of your areas, date-sorted.
2008 History 2008 Music 2008 Science
Back to nowSurprise me

Under the hood

It learns your taste with arithmetic you can audit.

No neural network, no cloud — an interest graph of weighted topics where watches, asks, saves and likes add weight, thumbs-down subtract, and everything slowly decays so your profile follows the present, not a permanent record of who you were two years ago.

Your interest graph — live demo
  • Programming & Software 4.2
  • History 2.8
  • Music 2.1
  • Food & cooking 1.6
  • Film 0.9

    What moves the needle

    Your actionEffect on the topic's weight
    Onboarding pick+2.2 per mapped topic (custom: +2.5; avoided words: −2)
    Asking about a topic+1.1 per detected topic
    A YouTube search+0.55, split across detected topics
    Watching 15+ s+0.25 to +2.4 by minutes watched (30-min cap); channels too; format counted
    Saving a pick+0.8 split across up to 4 detected topics
    Liking / un-liking on YouTube+1.6 / −1.8
    Thumbs up / down on a card+2.2 / −2.6 (downs also suppress similar items)

    Why-lines are drawn from the same graph

    “Because you keep gravitating to Programming & Software” “From CodeSchool — a channel you already watch” “Nods to your 2000s streak” “A stretch into History” “Fresh territory — picked to widen the mix”

    And every search is planned, ranked, filtered

    • 20–80 candidates per search — ads skipped, duplicates collapsed.
    • Top six, but never more than two from the same channel.
    • Era years are estimated honestly: strict matches first, graceful relaxation when they run thin.

    The ranking formula — every term is a plain number you could tune in the source

    score = (42 − position × 1.3)        ← YouTube's own relevance order
      + interest affinity × 16        ← your topic graph (query relevance ×1.25)
      + channel affinity × 1.1
      + era match × 15                ← exact decade = 1.0, within 3 years = 0.45
      + duration fit × 9
      + format fit × 8
      + level fit × 7
      + steering (dials, pins, mutes)
      + min(6, log10(views))
      − 8 if live
      + 4 if a playlist for a podcast ask
      − 14 if it matches a deeply-disliked topic
      − 15 if you've been shown it before

    Honesty

    “Not an LLM” is a feature, not a footnote.

    The design-document vocabulary sounds like science fiction. Here's exactly what Prism is — and, just as importantly, what it is not.

    What Prism is

    • A rules-and-heuristics engine. “Understanding” your sentence means matching words against a curated vocabulary of 31 topics and dictionaries of formats, moods, eras, levels and durations.
    • Deterministic and explainable. The same inputs produce the same outputs, and every pick literally shows the reason it was chosen.
    • Extractive by default. Summaries select the video's own most representative sentences — never paraphrased, never invented.
    • Arithmetic learning. An interest graph of weighted topics, with a 45-day half-life so old habits fade.
    • Fast and free. No API keys, no API bills, no rate limits of anyone else's making.

    What Prism is not

    • Not a cloud AI. No calls to OpenAI, Anthropic, Google or anyone else. Nothing leaves your machine except requests to youtube.com.
    • Not a general assistant. Ask it for a poem and it will treat that as a search. Its smarts are the vocabulary, the graph and the scoring — genuinely useful, but bounded.
    • Not an account. No sign-up, no sync, no server run by the project.
    • Not a black box. Every rule is in the source, and the whole “profile” is one JSON file you can read over coffee.
    • Not a generative paraphraser. “Summarize this video” never writes prose — it selects the video's own sentences.
    The honest caveats — everything Prism doesn't do well (yet)
    • Fixed vocabulary. 31 curated topics, English-first. Very niche or non-English requests fall back to whatever words survive stop-word filtering.
    • Era years are estimates. YouTube publishes relative ages only (“14 years ago”), so any year on a card is approximate — that's why cards show ≈.
    • Captions required. Summary and moment features depend on YouTube serving captions; auto-generated tracks are used but deprioritized.
    • Some videos can't embed (owner's choice, region locks). Prism detects it and offers “Open in a new tab” — but the in-Prism experience is not universal.
    • True full screen may be unavailable in the side panel — a Chrome surface limitation; Prism falls back to theater mode and says so. The full-page view supports real full screen.
    • YouTube changes its HTML periodically. The extractor handles both current renderer generations; if a future redesign breaks search, the fallback link always works.
    • Heavy personal use can trigger YouTube's bot check. Prism backs off for 5 minutes and paces background searches — but the check is YouTube's call, not Prism's.
    • Chrome-only (116+), installed unpacked. No Web Store auto-updates yet — you update by replacing files and pressing reload.
    • Single browser profile. Data doesn't sync across computers; use Export for a portable backup.

    Benefits

    What actually changes when you use Prism.

    For anyone who watches YouTube

    • Express intent, not keywords. Format, era, mood, duration, level — all understood in plain language.
    • “Why” is always visible. You can audit your own recommendations instead of guessing at a black box.
    • No bubble by default. Every batch ships with alternative angles; the digest suggests adjacent topics.
    • Era surfing. The time machine and ≈year chips are things YouTube's own UI simply cannot do.
    • A curriculum, not a pile. Learning paths turn “I want to learn X” into an ordered, time-budgeted sequence with real progress.
    • Answers from inside videos — moments, chapters, extractive summaries — without transcript sites.
    • Watch without tab-hopping. Play, queue, minimize, keep chatting — and carry playback between panel and full page.

    For the privacy-minded

    • No account, no cloud, no tracking, no telemetry. The only network traffic is to youtube.com.
    • One JSON file. Your entire “profile” is readable over coffee — and exportable any time.
    • Consent-first. Nothing collected before you accept; two kill-switches; private mode; per-topic forget that purges the memories too.
    • Deterministic answers. Same inputs, same outputs, every rule in the source.
    0 third-party servers 1 host permission: youtube.com

    For developers & tinkerers

    • Zero dependencies. Pure ES modules, readable end to end — no build step, no bundler, no npm install.
    • 278 automated tests (155 unit + 123 integration) that pin even YouTube's protobuf encodings and mock the whole pipeline.
    • A clean mapping onto a real design document — a great base for experiments: swap the scorer, add topics, add a model later.
    0 runtime dependencies 278 tests passing

    Privacy & your data

    Everything stays in your browser — and you can read all of it.

    Chrome's extension-local storage, a private database per browser profile. No analytics, no error reporting, no crash uploads, no third-party servers of any kind.

    0accounts
    0telemetry events
    1external string in the codebase
    100%on-device

    Where the data lives

    Storage keyWhat's in it
    prism.profileThe user “account”: consent record, interest graph, memories, shown-history, saved, playlists, learning paths, taste dials, feedback, benchmark, stats.
    prism.requestsThe Requests file — the append-only queue of collected thoughts (watch/search/like/theme signals).
    prism.responsesThe Responses file — delivered batches and the current For You deck.
    prism.chatsYour chat threads and their messages.
    prism.settingsTheme, notification/focus switches, engine heartbeat info.
    prism.pendingA one-shot handoff slot for the right-click “Ask about selection” feature (expires in 2 minutes).
    prism.handoffThe temporary player-handoff mailbox (cleared after use).

    What is collected — and when

    • Nothing before onboarding consent. The consent switch exists before any sensor turns on.
    • Watch activity: only after 15+ seconds of actual playback, and only while the tab is visible and the video is playing. Prism-player playback counts the same way.
    • YouTube searches you run on youtube.com itself (the query text on /results pages).
    • Likes/dislikes: only when clicked during a tracked session, and only in personalization mode.
    • Theme preference (light/dark) so the panel matches YouTube's look — collected before consent, purely cosmetic.
    • Private mode keeps an individual ask out of your memories entirely.

    Your controls

    Export my data

    One JSON file — prism-export-YYYY-MM-DD.json — with profile, requests, responses, chats and settings. Human-readable and yours.

    Clear memories

    Wipes memories, the interest graph, shown-history, feedback and stats — but keeps your chats, saved items and playlists.

    Delete everything

    A two-click flow (“Really? Click again to erase”) that removes all Prism storage and restarts you at calibration.

    Private mode

    The little lock in the composer. The ask is answered, then forgotten — it never touches memories or the graph.

    Mute & forget topics

    Muted topics vanish from recommendations; forget deletes the topic node and all its memories, with a toast confirming the purge.

    Two consent switches

    Background listening (collection) and personalization (graph tuning) — each one click, instant, and reversible.

    Audit the permissions — what Prism asks Chrome for, and why
    PermissionWhy Prism needs it
    storage + unlimitedStorageThe on-device account database (chats can grow).
    alarmsThe 1-minute Sleeping-Zero cycle.
    sidePanelTo live in Chrome's side panel.
    tabsTo open/reuse YouTube tabs for playback and focus the full-page view.
    contextMenusThe right-click “Ask Prism about selection”.
    downloadsThe JSON export download.
    scriptingRe-injecting the collector and launcher into already-open YouTube tabs after an update.
    notificationsThe opt-in fresh-picks ping.
    declarativeNetRequestWithHostAccessThe single scoped referer rule that makes in-Prism playback work.
    https://www.youtube.com/*Running searches, reading captions, watch pages. Nothing else.

    Architecture

    Four cooperating worlds. Zero dependencies.

    A Chrome extension split into sensors on youtube.com, a message router in the background, a five-module engine, and a local database — talking to nothing but YouTube itself.

    flowchart TB subgraph pages["youtube.com pages"] direction LR COL["content/collector.js
    watch sessions · searches · likes · theme · focus mode"] LAU["content/launcher.js
    floating spark button"] end subgraph surfaces["Prism surfaces"] direction LR PAN["side panel — ui/app.js
    chat · You tab · player · handoff"] FULL["full page — page/chat.html"] end SW["background/service-worker.js
    the router — ASK · SIGNAL · ONBOARD · PING · …"] ALM["chrome.alarms
    fires every 1 minute"] SYN["lib/synth.js — Neural Synthesizer
    ingest → ask → reply"] SZ["lib/sleeping-zero.js
    plans · searches · scores · filters · builds For You"] DB[("chrome.storage.local
    prism.profile · prism.requests · prism.responses · chats")] YWEB["youtube.com
    search pages · watch pages"] COL -->|messages| SW LAU -->|messages| SW PAN <-->|messages| SW FULL <-->|messages| SW SW --> SYN SW --> ALM ALM --> SZ SYN --> SZ SYN --> DB SZ --> DB DB --> YWEB classDef engine fill:#7C5CFF22,stroke:#8B6EF3,stroke-width:1.4px; classDef store fill:#D9553F1C,stroke:#D96A54,stroke-width:1.4px; classDef chip fill:transparent,stroke:#B9B3C6,stroke-width:1px; class SYN,SZ engine; class DB store; class SW chip;
    The 10,000-foot view: sensors, surfaces, the router, the engine, and the account database.

    The five modules that do the thinking

    ModuleThe role, in plain words
    The Neural SynthesizerThe conductor. Receives every chat ask, records it, parses intent, routes to the engine (or to captions/paths/small talk), delivers the reply, and ingests device signals into the profile. Also owns onboarding, saved items, playlists, paths, taste dials, topic flags, reset and export.
    The Sleeping-ZeroThe processor. Builds a search plan from intent + profile, runs YouTube searches, filters by era, scores and ranks candidates, picks the top six (max two per channel), finds alternatives, composes replies — and on the alarm cycle refreshes the For You deck. Also defines the bot-check back-off gate (5 minutes).
    the Interest GraphThe memory model. Weights, decay, absorption of watches/searches/likes/saves, affinity and why-lines, steering (pins, mutes, sliders), the benchmark report, the weekly digest, and onboarding anchors.
    The YouTube AdapterThe hands. Encodes YouTube's own filter parameters (sp), fetches results pages from the background with your session, parses the embedded JSON, and normalizes both generations of YouTube renderers. Parses durations, view counts and relative ages.
    The Intent ParserThe ears. Turns a sentence into a structured intent: topic text, topics, formats, era, duration, level, mood, and a kind (content / discovery / morelike / timetravel / mytopics / greet / thanks / help).

    The router's vocabulary

    The UI and background talk through a small typed message system. Every verb does exactly one thing:

    ASKSIGNALONBOARDNEW_CHATDELETE_CHATSAVE_ITEMCREATE_PLAYLISTTASTE_SETTOPIC_FLAGFORGET_TOPICFEEDBACKGET_FORYOUWAKE_TICKRESET_DATAEXPORTDOWNLOADSET_CONSENTENSURE_EMBED_RULEPLAY_VIDEOPLAY_ALLOPEN_PANELCONSUME_PENDINGPING

    Talking to YouTube itself

    Prism uses no API key. It runs the same search URLs YouTube's own website uses, from the background worker, with your browser session. The sp parameter — YouTube's protobuf-encoded filter blob — is built byte-by-byte, and tests pin the outputs against YouTube's known values:

    EgIQAQ== videos only EgIYAg== over 20 minutes CAMSAhAB era-sorted video
    • Bot-check safety. If YouTube answers with its human-check page, Prism detects it, goes quiet for 5 minutes instead of hammering, and tells you to clear the check once.
    • Background refreshes run in small paced batches (max two parallel searches, 250 ms apart) so bursts are less likely to trip the check.
    • Failed searches retry once without filters; if YouTube is unreachable, Prism offers “Open this search on YouTube” instead of failing silently.

    The player's plumbing

    A YouTube IFrame embed with enablejsapi=1, driven over postMessage: play/pause/seek out; playback-state and current-time in — with a listening handshake retried up to 20 times because frames can be slow to boot.

    • A 5-second heartbeat accumulates watch time; the seconds flush as a watch signal on close, switch or hide (if ≥15 s).
    • Queue advance happens on the player's own “ended” event.
    • The referer fix is one narrowly-scoped declarativeNetRequest rule (id 153) that applies only to Prism's own player frames.

    The whole tree, if you want it

    No build step, no bundler, 19 plain JavaScript files. The engine narrates its work in the UI while it runs, and the file layout reads like the architecture.

    Open the file-by-file tree 
    personal-youtube/
├── manifest.json            The extension's ID card: name, permissions,
│                            side panel, content scripts, icons.
├── package.json             Dev-only metadata: three npm scripts, zero dependencies.
├── README.md                Developer quick overview.
├── PROJECT_GUIDE.md         The complete guide.
├── SOFTWARE DESIGN DOCUMENT.pdf   The BeezGroup 2022 design document.
│
├── background/
│   └── service-worker.js    The router + alarm host + embed rule + notifications.
├── lib/
│   ├── store.js             Storage keys, defaults, chat & memory helpers.
│   ├── topics.js            The vocabulary: 31 topics, 11 formats, matcher.
│   ├── intent.js            Sentence → structured intent.
│   ├── ytsearch.js          sp encoder, search fetch, ytInitialData parsing.
│   ├── interest.js          The interest graph: absorb, decay, affinity, why-lines.
│   ├── sleeping-zero.js     Plan → search → era filter → score → pick → voice.
│   ├── synth.js             Ask pipeline, signals, playlists, paths, onboarding.
│   ├── embed.js             Embed URLs + plain-English error messages.
│   ├── learn.js             Learning paths: parse, build, progress, sessions.
│   └── transcript.js        Captions: tracks, parsing, moments, summaries.
├── content/
│   ├── collector.js         The sensors on youtube.com; focus-mode CSS.
│   ├── launcher.js          The floating spark button.
│   └── launcher.css         Its styling.
├── ui/
│   ├── app.js               The whole workspace (~2,300 lines).
│   ├── app.css              The design system (~1,845 lines).
│   └── icons.js             Hand-drawn SVG icon set + brand mark.
├── sidepanel/ · page/       The 12-line shells for panel and full page.
├── assets/                  Generated toolbar PNGs.
└── scripts/
    ├── selftest.mjs         155 pure-module checks.
    ├── integration.mjs     123 end-to-end checks (mocked Chrome + YouTube).
    ├── check.mjs           Parse-check every JS file; validate manifest + icons.
    └── make-icons.mjs      Dependency-free PNG icon generator.

    FAQ

    Honest answers to the obvious questions.

    “Search results came back empty — I got the human-check message.”

    YouTube intercepted the request with its not-a-robot page. Open youtube.com, clear the check once, wait a few minutes (Prism pauses searching for 5 minutes on its own), then try again.

    “The player says error 153 / missing referrer / Video unavailable.”

    YouTube's embed identity rules. Prism's fix is automatic; if you still see it, reload the extension at chrome://extensions (this re-registers the referer rule) or use Open in a new tab. Some videos simply forbid embedding — that message means it's the owner's choice.

    “The player is taking longer than usual to start.”

    Shown after a 10-second stall — often a YouTube hiccup or a pending human-check. Try Try again, or open in a new tab.

    “Prism was just updated — close and reopen this panel.”

    Chrome invalidates open extension pages when the extension reloads. Close the panel (or the full-page tab) and open it again.

    “Nothing is being learned from my normal YouTube watching.”

    Check the You tab: Background listening and Personalization must both be on. Also note that only sessions of 15+ seconds of actual playback count, only while the tab is visible, and likes only register when clicked during a tracked session.

    “I turned personalization off — does search still work?”

    Yes. Search, the time machine, learning paths and captions all work; only the graph tuning of results and the For You deck stop.

    “Where do I see everything it knows about me?”

    The You tab: benchmark, memories timeline, topic list, eras and formats. “Export my data” gives you the raw JSON.

    “How do I start over?”

    You tab → Delete everything (two clicks). Or Clear memories to keep chats, saves and playlists but reset the taste model.

    “The spark button disappeared or duplicated.”

    It re-attaches on navigation and steps aside in fullscreen. After an extension reload it self-heals with a “takeover” token when you next visit YouTube. Worst case, refresh the YouTube tab.

    “Can I use this on Firefox or Edge?”

    Chrome 116+ is the target. Chromium-based browsers may work but are untested; Firefox's extension system differs (no side-panel API in the same form).

    “Does it work offline?”

    The panel itself works and your data is local, but search, captions and playback need youtube.com reachable — that's the only network Prism uses.

    Glossary

    The vocabulary, in plain English.

    Extension
    A small program that adds features to the Chrome browser.
    Manifest V3
    Chrome's current extension format and security model (the one Prism uses).
    Side panel
    Chrome's built-in dockable pane next to a web page; Prism's primary home.
    Service worker
    The extension's background brain — invisible, and kept awake by a 1-minute alarm.
    Content script
    A small script injected into web pages (here: youtube.com) to observe and add UI.
    chrome.storage.local
    Chrome's private per-extension database on your disk. Where all of Prism's data lives.
    ytInitialData
    The big JSON blob embedded in every YouTube page — what Prism parses results from.
    sp parameter
    YouTube's compressed filter blob in search URLs (type, duration, sort…), encoded byte-by-byte.
    Protobuf
    A compact binary format Google uses; sp is a tiny protobuf message, base64-encoded.
    Renderer
    YouTube's internal UI data objects; older and newer generations both get parsed.
    IFrame / embed
    A video player from youtube.com shown inside another page (here: inside Prism).
    postMessage
    The standard way a page talks to an embedded player (play, pause, seek, status back).
    Referer
    A header saying which site a request came from. YouTube requires it for embeds; Prism sets one for its player frames only.
    declarativeNetRequest
    Chrome's privacy-preserving way to modify web requests. Prism uses exactly one rule, for one header.
    Interest graph
    Prism's on-device map of your taste: topics, channels, eras, formats with weights.
    Decay
    The graph's slow forgetting — weights halve every 45 days, so taste follows the present.
    Calibration
    The 15-second first-run setup where you pick areas and give consent.
    For You deck
    The background-refreshed “Picked for you” strip on the welcome screen.
    Time machine
    Builds a deck of era-specific keepsakes across all your chosen areas.
    Learning path
    An ordered, numbered curriculum for a topic, split into time-budgeted sessions.
    Extractive summary
    A summary made from the source's own sentences — never generative. Prism always uses extractive.
    Autonomous cycle
    The once-a-minute background housekeeping and refresh run — the Sleeping-Zero waking up.

    Early access

    Ask YouTube anything — starting with you.

    Prism is in the post-development phase and soon releasing. Early-access members get the packaged Chrome build first, fresh-picks updates as they ship, and a direct line for feedback.

    Join the early-access community and help shape the future of Prism.

    Developer access

    • Start building now. The entire source installs unpacked today — zero dependencies, no build step, all 278 tests included (npm test).
    • First in line for sources. Developer signups are flagged for source access and repo drops as v1.x opens up.
    • Shaped with you. Bugs and extension points — topics, scorer, message router — get a direct line to the team.

    Open the form in a new tab