How RVLTION works.

Getting started

Leave RVLTION running and work normally. It records what you copy, on this machine only. Nothing needs configuring, and there is no account.

After a while it will notice that a run of copies was about one thing and offer to reveal it. You decide whether that connection is worth keeping. Everything else in the product follows from that one decision.

RVLTION currently runs on Windows. See supported platforms.

How capture works

On Windows, RVLTION registers as a clipboard format listener. It is told when the clipboard changes rather than polling for it, which is why it costs almost nothing while idle.

Each change goes through the same pipeline before anything is stored:

1. Read the clipboard contents.
2. Apply the privacy gate. Anything that fails it is dropped here and never written.
3. Classify what the fragment is: a link, a price, a note, code, a colour, and so on.
4. Normalise it and hash it, so copying the same thing twice does not duplicate it.
5. Write it to SQLite, as a unique item plus one event for this particular copy.

The split between items and events matters. Copying the same link during two different sittings is two events of one item. Detection reasons about events, and search reasons about items.

When a copy is missed

Only one process may hold the Windows clipboard open at a time. If another application is holding it, RVLTION retries with a short backoff and then gives up. Copies genuinely lost this way are counted and shown in the status bar rather than hidden. Nothing keeps a recoverable record of them, so they cannot be reconstructed later.

Detection and the reveal

Detection runs in three deterministic stages. The event stream is split wherever you went quiet, because silence is the strongest available evidence that one sitting ended. Each run of activity is then divided into contexts by what the fragments are about. Each context that survives is scored.

The middle stage is the one that matters. A run of activity is where RVLTION looks, not what it concludes: two minutes of your time can contain research, a message, a piece of writing and a link, and those do not become one thing because they happened close together.

Nor do they need to take turns. You can research headphones, write a verse, hit a compiler error, go back to the verse, look at an unrelated product, and return to the headphones, and RVLTION will separate those threads without a single pause anywhere in the sequence. Picking something up again is normal, and it does not start a new subject.

What can make two fragments related

RVLTION keeps two questions apart, and only one of them can create a relationship.

• What a fragment is about. Repeated product names, model numbers and meaningful words. This is the only evidence that can group anything.
• Where and when it came from. The site, the application, the clock. These can strengthen a relationship that already exists. They can never establish one.

So five things bought from one shop are five things from one shop, not one project. Everything typed into one editor is not one subject. And two fragments copied seconds apart with nothing in common are two fragments, not a session.

What kind of work it is

Two fragments can share a word by accident. A song lyric and a set of measurements can both use the word impedance, and one of them is using it as an image. Counting words cannot tell the difference, because the shared word really is there.

So RVLTION also reads what kind of material a fragment is: a link, a price, code, program output, a short note, reference material, long-form writing, a conversation, or honestly unclear. Different kinds of work argue against a connection built on ordinary words alone.

This is read from the fragment itself and never from the window it came from. You can write research notes in a text editor and a song in a code editor, and RVLTION should not care which. It also gets this wrong sometimes, so an unclear reading is allowed to support a connection and never to block one.

A shared specific name still wins. A code snippet that names the same product as the notes around it belongs with them, whatever shape it is in.

A context has a centre

A fragment joins by agreeing with the context as a whole rather than with whichever member happens to be nearest. Without that rule a chain of weak links collapses everything into one umbrella: keyboards relate to a keycap note, the keycap note mentions resin, and suddenly resin printing is part of your keyboard research.

One ordinary word shared with every member is still one word, and does not admit anything. Agreement is also weighed against how much text there is to agree by accident: two short notes sharing two words are about the same thing, while two very long pastes sharing two words are not.

Words that are the same word

Amplifier, amplification and amplify are one word wearing three endings, so RVLTION reduces them to a common root and lets them meet. When that is what connected two fragments, the explanation says related wording.

It says wording rather than meaning because that is all it is. This reads spelling. It cannot tell that headphones and cans are the same thing, and it will not pretend to. There is no model here, local or remote.

The same thing, or merely a related one

Belonging has two sides, and plenty of material sits on neither. A coffee grinder and an espresso machine are the same hobby and not the same subject. RVLTION separates those answers: the same thing, part of the same work, related but about something else, supporting material, unrelated, or not clear yet.

Related is decided on evidence, not on a hunch. If the fragments around you keep naming one product and a new one names a different product, and all they have in common is vocabulary the whole group already uses, that is a neighbouring subject and it stays out.

When neither side names anything, RVLTION cannot tell two subjects in one field apart. A tripod and a lens are both photography, and if they share a word it will group them. Telling them apart needs to understand what the words mean, and it does not.

Why something was copied

RVLTION reads what shape a fragment is, and separately what it appears to have been copied for: looking something up, writing something, fixing something, working on code, talking to someone, or unclear.

Those two readings disagree usefully. A compiler error and the code that caused it look nothing alike and are one piece of work. A message to a friend about a tool and the research about that tool look very alike and are not.

Unclear is the common answer and the correct one. Most fragments do not say why they were copied, and a fragment that says nothing is never allowed to argue against a connection.

Separate, and related

Two threads that are built around the same thing are recorded as related rather than merged. An espresso machine and a coffee grinder are one hobby and two pieces of work, and collapsing them into one session would lose the distinction you actually care about.

Understood, and not shown

RVLTION understands more than it displays. A single piece of writing copied between four notes about a tool is understood completely: it is one coherent thing, and it is not the tool research. It is also not worth a card on its own. If a second piece of the same writing arrives, it becomes a thread.

When two contexts both want something

A fragment goes to whichever context explains it best, and only if that context is clearly better than the next one. If two explain it about equally well, RVLTION holds it rather than picking. Which group happened to form first is not evidence.

Holding is a real answer here. A held fragment remembers which contexts wanted it and why that was not enough, so when more arrives it can be looked at again instead of being quietly forgotten.

Both of these are visible. When RVLTION shows you something it found, it also names the thread it deliberately kept apart, and any fragment it looked at and did not place. They appear under the reasons and are styled apart from them, because a neighbouring thread is not a reason anything belongs together. What the engine knows and what it shows you should not be two different things.

One place where belonging is decided

Every question of the form "does this belong with those" goes through a single piece of code, and nothing else in RVLTION is allowed to answer one. It is given the reasons for, the reasons against, and the reasons that are merely incidental, and it returns an answer together with the evidence that actually decided it.

The reasons are named things rather than numbers: they share a name, they name different things, they are the same kind of work, this one stands alone. There is no total, no score, and nowhere for a similarity measurement to quietly become a decision. If RVLTION ever gains a new way of reading meaning, it will arrive here as one more reason to be weighed against the others, not as a verdict.

Languages other than English

RVLTION reads a fragment in whatever script it was written in. It does not guess which language you are using, because guessing from forty characters is unreliable and a wrong guess applies one language's rules to another. It looks at the characters instead, which is not a guess.

Chinese and Japanese are not written with spaces between words, so those fragments are split where the writing system changes, which in Japanese is usually where a word ends. Arabic and Hebrew attach small words like and and the to the front of the next word, so both spellings are kept and either can match. Vowel marks, which are optional in both, are set aside before matching.

One fragment can hold several scripts at once, and that is ordinary rather than exceptional. A note that says HD 600 in the middle of an Arabic sentence is read as both, and meets an English note about the same headphones.

The limit, stated plainly. Two notes about the same subject in two different languages, with no shared name written in Latin letters, cannot be connected. The Arabic word for headphones and the English one have nothing in common to find. Recognising them as the same thing needs to know what the words mean, and RVLTION does not.

Something you wrote, at any length

RVLTION reads the shape of a fragment to tell writing from notes: whether lines break where the line ends rather than where a sentence does, whether they are of an even length, whether a phrase comes back, whether it is in the first person, and whether it is dense with the brackets and numbers that writing does not have.

None of that is a length. Two lines of something you wrote are recognised as two lines of something you wrote, and a very long configuration file is not mistaken for an essay.

This makes RVLTION more careful, never less willing. It means wanting better evidence before folding your own writing into a body of research. If you are deliberately collecting lyrics, references and production notes together, that is one piece of work and RVLTION will let it be one.

What you teach it

When you keep a connection, dismiss one, or take something back out of a context, RVLTION records what that says about the two subjects involved, along with the reasoning it had used. Once is an incident, so nothing changes until you have said the same thing twice.

It never learns where something came from. Not the application, not the website, not the folder. Concluding that an editor means one kind of work, or that a shop means one kind of subject, is the exact mistake this product exists to avoid, and there is nowhere in the database to store it. Everything learned can be read back as a sentence and removed one at a time.

Not everything belongs somewhere

A fragment that matches nothing is left alone. That is an answer, not a gap in one, and it is the answer RVLTION prefers. A wrong connection costs more than a missed one: you can always keep something yourself, but a product that confidently tells you your own writing is part of your shopping has spent trust it does not get back.

Fragments with no subject of their own, a price or a colour, never define a context. They are included where a context surrounds them in time, which is what a shopping session actually looks like.

The explanation is the evidence

Every context carries its reasons in plain language, strongest first, and what it was about leads. Timing comes last, because how many minutes something took is the setting a reason happened in rather than the reason. No score is displayed, because a number would imply a precision the evidence does not have.

Revelations lifecycle

A detected session is temporary. A Revelation is a context you decided was worth preserving. Keeping one is the only way a Revelation is ever created. RVLTION does not create them on its own.

• Provenance is snapshotted. The reasons a Revelation exists are copied at the moment you keep it, so they survive the underlying history being cleared.
• Later additions stay distinguishable. What RVLTION found and what you agreed to add afterwards are recorded separately.
• Keeping twice is one Revelation. Enforced by a unique index in the database rather than by a check that a race could outrun.
• Removing an item does not delete it. Only the membership goes. The item stays in your history and in any other Revelation that references it. Context ownership and history ownership are different things.

Reconnection

Later activity can resemble something you kept. When it does, RVLTION offers a suggestion and stops there. It never adds anything on its own.

Reconnection is a different model from session detection, not the same scoring with a lower threshold. Detection asks whether some items cohere with each other now. Reconnection asks whether new activity belongs to one specific preserved context, which is an asymmetric question: fresh items measured against a fixed profile.

The gates exist to keep it quiet:

• A single matching item never suggests, unless it carries a phrase you have already confirmed for that Revelation.
• Shared ordinary words with no entity and no prior confirmation need more items before they count.
• Items you declined are excluded permanently, so the same suggestion does not return.
• A Revelation with an unanswered suggestion stays silent rather than asking again.

Silence is a correct outcome. Interrupting wrongly costs more than missing a connection.

Find and retrieval

FIND is for the case where you half remember something: a product name, the site it came from, the application you were in, roughly when. It is not natural language understanding, and asking it a question in prose will not work better than naming the thing.

It matches on deterministic signals and ranks locally:

• Exact phrase. The whole query occurring verbatim is the strongest signal.
• Entity. A repeated product name or model number, weighted by how much of the query one entity accounts for.
• Token coverage. The share of your meaningful query terms present.
• Domain and application. Where a fragment came from.
• Recency. A tie breaker only. A perfect match from months ago still outranks a weak one from ten minutes ago.

Where something came from is not what it is about

A domain and an application say where a fragment came from, never what it is about. So query terms answered by a site or an app are set aside, and what remains must still match. Searching reddit alone finds Reddit. Searching reddit keyboard will not return a sourdough thread that merely happens to be on Reddit.

Every result carries its reason. Queries are never written down: closing FIND forgets what you typed, because a search term can be as revealing as the thing it finds.

Data and storage

Your history is one SQLite file in your user profile.

%APPDATA%\app.rvltion.desktop\rvltion.db

On this machine that resolves to C:\Users\<you>\AppData\Roaming\app.rvltion.desktop\rvltion.db. It sits outside the installation directory deliberately, so uninstalling RVLTION does not remove your history and an upgrade cannot discard it. Neither installer touches that folder. If you want the data gone, delete the file yourself.

Alongside it you may see rvltion.db-wal and rvltion.db-shm. Those are SQLite write ahead log files, normal and managed automatically.

Schema changes are forward only migrations tracked by SQLite user_version. Clearing your history also empties the search index, because the index is derived from the same rows rather than being a second copy.

Privacy boundary

What RVLTION does not do, stated as facts about the build:

• There is no HTTP client, no socket, and no telemetry in the dependency tree.
• There is no fetch, XHR, WebSocket, or beacon in the frontend source.
• The content security policy is default-src 'self', which blocks outbound requests at the webview.
• There are no Tauri plugins, including no updater.
• No clipboard content is sent to any AI service. There is no model, local or remote.
• There is no account and no sync.

Secrets are excluded before storage

The privacy gate runs before anything is written to disk, in three layers:

1. The clipboard privacy flags that password managers set, which RVLTION honours on Windows. See supported platforms for why this layer does not work on macOS or Linux yet.
2. A list of protected applications, matched against whatever identifier the platform provides.
3. Content heuristics: twelve published token shapes such as PEM keys and provider API keys, then a general entropy check.

The third layer is best effort and will miss things. The first two carry the real guarantee. The default policy for a suspected secret is to never store it, so a blocked secret leaves nothing behind except a counter.

What is not true

Your history is not encrypted. It is an ordinary SQLite file with ordinary file permissions, and anyone who can read your user profile can read it, exactly as with any other local application data. RVLTION keeps secrets out of that file. It does not protect the file itself, and does not claim to.

Supported platforms

Four separate things are often blurred together into the word supported. This table keeps them apart, because a platform whose code exists is not the same as a platform whose binary has been run.

• Implemented. The platform specific code is written and in the repository.
• Built. A compiler has produced a binary for that platform.
• Runtime verified. That binary has been launched on that platform and observed capturing the clipboard.
• Signed. The artifact carries a certificate the operating system trusts.

Windows and Linux on an X11 session are both usable today. The Linux binary, its Debian package and its AppImage have each been launched and observed capturing the clipboard, and the same binary serves both Linux session types. The Wayland row keeps its No because the wlr data control protocol has not been exercised on a compositor that implements it, and that is a different thing from the binary working. macOS has no Apple SDK on the machine this project is developed on, so it has never been compiled. Nothing on any row is signed.

Only clipboard notification, clipboard reading, source application identification and the operating system privacy conventions are platform specific. Everything else, the item model, the privacy gate, classification, storage, detection, Revelations and FIND, is platform neutral and works unchanged.

How each platform reads the clipboard

The three platforms do not offer the same mechanism, and pretending otherwise would hide real differences in cost and reliability.

• Windows uses notification. RVLTION registers as a clipboard format listener and the system tells it when the clipboard changes. Nothing runs between copies.
• macOS polls, because there is nothing to subscribe to. AppKit exposes a pasteboard change counter and no change notification. Every clipboard tool on macOS polls that counter. RVLTION reads it four times a second, which is cheap, but it does mean two copies of the same text within one interval are seen as one.
• Linux polls as well. On X11 the selection owner changes without a general notification to unrelated clients. On Wayland the compositor governs access deliberately, and only a compositor implementing the data control protocol lets a background application read the clipboard at all.

One privacy layer does not survive the crossing. On Windows, password managers mark a copy as excluded from history and RVLTION honours that before anything is written. macOS and Linux have equivalent conventions, but the clipboard library used on those platforms reads text and images rather than arbitrary clipboard types, so it cannot see them. On macOS and Linux the source application check and the content heuristics carry the whole load, and heuristics miss things. This is a known gap, not a decision.

Wayland, stated plainly

Wayland is designed to stop background applications reading the clipboard. There is no way around that, and RVLTION does not attempt one. It relies on the wlr data control protocol, which compositors including Sway, Hyprland, river and most wlroots based compositors implement.

GNOME and KDE Plasma under Wayland do not implement that protocol at the time of writing. On those sessions clipboard capture cannot work. RVLTION reports that it is unavailable and says why, rather than starting and silently recording nothing. If you need capture on GNOME or Plasma today, log in to an X11 session instead.

Signing

RVLTION is unsigned on every platform. There is no Windows code signing certificate and no Apple Developer ID, so nothing RVLTION produces is verified or trusted by the operating system, and calling it either would be false. Windows SmartScreen warns on a binary it has not seen, and Smart App Control may refuse it outright. On macOS an unsigned application is blocked by Gatekeeper until it is explicitly opened. Do not switch Smart App Control off to work around this: it cannot be switched back on without reinstalling Windows. Do not disable Gatekeeper either. Both are the correct fix for the wrong problem, and the real fix is a certificate this project does not yet have.

Building from source

You need Rust 1.85 or later with the MSVC toolchain, Node 20 or later, and Visual Studio Build Tools with the C++ workload.

npm install
npm run app          // development, opens the window
npm run app:build    // release build and installers

A release build takes roughly eight minutes. It produces the executable plus an NSIS installer and an MSI. Use the NSIS one: it installs per user without administrator rights, and installing both formats of the same version conflicts because they write separate uninstall entries.

Install the result rather than running the build output directly. On a machine with Smart App Control enforced, the freshly linked executable in the target directory is sometimes refused while the installed copy of the same build runs normally.

Verification

npm run check                          // typecheck and frontend tests
bash scripts/cargo-sac.sh test --lib   // backend tests
npm run site                           // this website, locally

About RVLTION

RVLTION started from a small observation: a clipboard history can tell you what you copied, and almost never what you were doing. The fragments survive and the reason evaporates.

So the product is built around context rather than items. It records locally, notices when a run of copies is about one thing, and lets you preserve that connection with the evidence attached. The intelligence is deterministic on purpose. Every conclusion it reaches can be explained in a sentence, which is the only way a suggestion about your own work is worth trusting.

There is no company, no account system, and no server. It is a desktop application that keeps its data on your desk.