Text Diff Checker
Line-by-line comparison using LCS (Longest Common Subsequence) algorithm —instantly see what was added, removed, or unchanged
Text Similarity Checker
Cosine similarity with TF (Term Frequency) vectorization —compare two texts and get a 0—00% similarity score. Great for comparing AI-generated outputs or detecting paraphrased content
Deduplicate, Sort & Number Lines
Remove duplicate lines (keeping first occurrence), sort alphabetically A→Z or Z→A, randomize order, or add line numbers —all in one click
How Text Similarity Checker Works — Cosine Similarity & TF Vectorization
Rosenav's text similarity checker uses cosine similarity — a mathematical measure of the angle between two word-frequency vectors — to produce a 0-100% overlap score. Unlike simple string matching, cosine similarity captures semantic overlap: two texts using similar vocabulary in similar proportions will score high even if their exact wording differs. The checker provides 11-tier detailed descriptions every 10 percentage points, from "Completely unrelated" to "Identical vocabulary distribution," giving you actionable interpretation alongside the raw percentage.
From Raw Text to Mathematical Vectors — Tokenization & TF
The similarity engine transforms raw text into a mathematical representation in three deterministic steps. Step 1 — Normalization: All text is lowercased and punctuation is stripped to standardize the input; this ensures "Hello," "hello," and "HELLO!" all map to the same token. Step 2 — Tokenization: The normalized text is split on whitespace boundaries to extract individual word tokens. Each unique word across both texts becomes a dimension in a shared vector space — the more unique words, the higher the dimensionality, but cosine similarity handles sparse vectors efficiently. Step 3 — Term Frequency (TF) counting: For each unique word, its count in each text is tallied. For example, if Text A is "the cat sat on the mat" and Text B is "the dog sat on the floor," the shared vocabulary is [the, cat, sat, on, mat, dog, floor], yielding Text A = [2,1,1,1,1,0,0] and Text B = [2,0,1,1,0,1,1]. The cosine of the angle between these vectors — computed as dot product divided by the product of vector magnitudes — produces a score from 0 (orthogonal, completely different vocabulary) to 1 (identical direction, same vocabulary proportions). The tool displays token counts for both texts so you can verify the comparison basis.
The Cosine Formula — Why Angle Beats Distance for Text Comparison
Cosine similarity measures the direction of vectors, not their magnitude — and this distinction is the key reason it outperforms Euclidean distance for text comparison. Euclidean distance would flag a 500-word and a 5,000-word article on the same topic as "far apart" purely due to the magnitude difference in word counts. Cosine similarity normalizes for document length by dividing the dot product by the product of vector magnitudes (∥A∥ × ∥B∥), measuring only the angle between the two vectors. Two texts that use the same words in the same proportions receive a cosine similarity of 1.0 (100%) regardless of whether one is 10× longer. This length-invariance property makes cosine similarity the standard metric in information retrieval, plagiarism detection, and LLM output comparison — it answers "are these texts about the same thing?" rather than "are these texts the same length?" The Rosenav checker displays the percentage score, a color-coded progress bar (green ≥90%, yellow ≥70%, orange ≥40%, red below 40%), and the matching 11-tier qualitative description for immediate, intuitive interpretation.
AI Output Comparison — The Primary Use Case for Similarity Detection
One of the most powerful applications of cosine similarity is comparing outputs from large language models (LLMs). When you run the same prompt through ChatGPT, Claude, Gemini, or any other LLM multiple times — or compare responses across different models — cosine similarity quantifies how consistent or divergent the outputs are. A score of ≥90% suggests the model is highly deterministic for that prompt; 70-89% indicates the same core content expressed with different phrasing; 40-69% shows the models diverge significantly in vocabulary and structure; below 40% suggests fundamentally different responses to the same query. This data helps prompt engineers tune for consistency, content creators verify originality of AI-assisted writing, researchers compare model behaviors across providers, and educators detect potential AI-generated content in student submissions. The tool also educates users that high similarity does not automatically mean plagiarism — two independent summaries of the same source material will naturally share vocabulary, and the cosine score must be interpreted with domain context. Rosenav addresses this by providing both the raw percentage and the tiered qualitative interpretation, encouraging informed judgment rather than automated flagging.
Understanding Your Similarity Score — The 11-Tier Description System
Every similarity result includes a human-readable tier description calibrated to the percentage score in 10-point increments. This system bridges the gap between a raw number and actionable insight. The 11 tiers are:
- 100% — Identical vocabulary distribution: the two texts are effectively the same.
- 90-99% — Nearly identical: the texts are almost the same with only trivial wording differences.
- 80-89% — Strong similarity: the texts are closely related with minor wording differences.
- 70-79% — High similarity: the texts share most vocabulary with some variation.
- 60-69% — Noticeable similarity: substantial vocabulary overlap indicates related topics.
- 50-59% — Moderate similarity: the texts share a fair amount of vocabulary but differ in focus.
- 40-49% — Moderately different: partial vocabulary overlap but the texts diverge significantly.
- 30-39% — Mostly different: limited vocabulary overlap suggests distinct subject matter.
- 20-29% — Largely dissimilar: the texts cover different topics with only occasional shared terms.
- 10-19% — Almost entirely different: only a few incidental words overlap between the texts.
- 0-9% — Completely unrelated: the two texts share virtually no vocabulary in common.
These descriptions are generated client-side by the same JavaScript that computes the score, so they are always perfectly synchronized. The color-coded progress bar (green → yellow → orange → red) provides an at-a-glance visual complement to the numerical score and text description, making results scannable even when comparing many text pairs in rapid succession.
How Text Diff Works — LCS Algorithm & Line-Level Comparison
While cosine similarity tells you "how much" two texts overlap, the Rosenav text diff checker shows you exactly "where" they differ. It implements the Longest Common Subsequence (LCS) dynamic programming algorithm to find the optimal alignment between two texts at the line level, marking each line as unchanged, added, or removed. This is the same algorithmic foundation used by git diff and professional code review tools — now running instantly in your browser with zero uploads.
The LCS Algorithm — Finding the Optimal Edit Sequence
The Longest Common Subsequence (LCS) problem is a classic dynamic programming challenge: given two sequences, find the longest subsequence present in both in the same order. For text diff, each line is treated as an element in the sequence. The algorithm builds a 2D DP table where dp[i][j] stores the length of the LCS between the first i lines of text A and the first j lines of text B. With O(m×n) time and space complexity, it efficiently handles texts up to several thousand lines in the browser. After building the DP table, a backtracking pass reconstructs the actual diff: lines that match are marked "unchanged," lines present only in the original are "removed" (red, - prefix), and lines present only in the modified text are "added" (green, + prefix). This produces the familiar unified diff format — the same visual language developers use daily in version control.
Line-Level vs. Character-Level Diff — When Each Matters
Rosenav uses line-level diffing as the default because it produces cleaner, more actionable output for most real-world use cases: comparing code revisions, reviewing document edits, checking AI output variations, or validating configuration changes. Line-level diff groups related changes together and avoids the noise of per-character highlighting. Each line is treated as an atomic unit — if a single character changes, the entire line is marked as removed-then-added rather than showing a jumble of inline color coding. For content and code comparison tasks, this yields the most interpretable diff. The result includes a stats summary — total unchanged, added, and removed lines — giving you an instant quantitative measure of how much two texts differ, complementing the visual line-by-line display.
Real-World Applications — Beyond Just Code Diff
While line-level diff originated in software version control (the Unix diff command dates to 1974), modern applications extend far beyond code. Content editors use diff to track revisions across article drafts, blog posts, and documentation. AI practitioners compare outputs from different prompt variations to see exactly what changed between two LLM responses. Legal professionals compare contract versions clause by clause. Data analysts validate CSV exports and configuration files after automated transformations. Students compare essay drafts to see their editing progress. For the best workflow, pair the diff tool with the similarity checker: run similarity first to quantify how different two texts are, then use diff to inspect exactly where those differences occur. Both tools run instantly client-side — paste, click, and see results immediately with no registration or uploads.
Deduplication, Sorting & Line Operations —How Each Tool Works
The third tab bundles five common line-level text operations into a single interface. Remove duplicate lines while preserving first-occurrence order. Sort alphabetically ascending or descending using locale-aware comparison. Randomize line order with cryptographically secure shuffling. Add padded line numbers for reference. Each operation is instant and runs entirely in your browser.
Deduplication —Preserving Order, Removing Redundancy
The deduplication algorithm processes lines sequentially, maintaining a hash set of seen values. Each line's first occurrence is kept; all subsequent duplicates are removed. This first-occurrence-wins strategy preserves the original ordering while eliminating redundancy —ideal for cleaning email lists, removing duplicate URLs from scraped datasets, consolidating keyword lists, or de-duplicating log entries. The tool reports how many lines were removed so you can quantify the duplication rate at a glance. Unlike simple sort | uniq pipelines that reorder your data, Rosenav's dedup preserves your original sequence —a critical feature when line order carries meaning (timestamps, ranked lists, sequential data).
Sorting Options —A→Z, Z→A, and Random Shuffle
Three sort modes cover common text processing needs. Sort A→Z arranges lines alphabetically in ascending order using locale-aware string comparison (localeCompare with base sensitivity), correctly handling accented characters and mixed case. Sort Z→A reverses the order for descending needs. Randomize shuffles lines using the Fisher-Yates algorithm powered by crypto.getRandomValues() —the same CSPRNG used for cryptographic key generation —ensuring unbiased, unpredictable shuffling suitable for A/B test assignment, randomized survey question ordering, or lottery-style selection. The shuffle produces every possible permutation with equal probability, unlike Math.random()-based shuffles that exhibit subtle statistical biases.
Line Numbering —Padded, Aligned, Readable
The line numbering feature prepends each line with a zero-padded sequential number and a vertical bar separator (e.g., 1 | content, 42 | content). The padding width automatically adjusts to the total line count —a 9-line text uses single-digit padding while a 1,000-line text uses 4-digit padding —keeping numbers right-aligned for easy scanning. This is useful for referencing specific lines during code reviews, adding reference numbers to datasets, preparing text for annotation workflows, or creating numbered lists from raw data. The operation is reversible: copy the numbered output, paste it back, and use a simple text editor to strip the prefixes if needed.
Zero-Upload Architecture —Why Your Text Never Leaves Your Browser
Many online text tools silently upload your content to remote servers for "processing" —exposing sensitive documents, proprietary code, or confidential data to third-party infrastructure. Rosenav inverts this model: every computation —LCS-based diff, TF-IDF-inspired cosine similarity, deduplication, sorting, shuffling, and line numbering —executes entirely within your browser's JavaScript runtime. You can disconnect from the internet after page load and all tools continue working perfectly offline.
Verifiable Privacy —Inspect the Network Tab Yourself
Rosenav operates without login walls, account registration, or tracking cookies of any kind. There is no backend server to POST text to, no cloud-based analysis queue, and no third-party API integration. Every computation runs locally on your device's CPU via vanilla JavaScript. This architecture provides three verifiable guarantees: (1) Open your browser's Developer Tools Network tab while using any tool —you will observe exactly zero outbound requests. (2) Disconnect from the internet entirely after the page loads —every function including text diff, similarity check, and line operations continues to operate without degradation. (3) The entire source code is delivered as readable, unobfuscated JavaScript —right-click View Source to audit every function. No localStorage, no sessionStorage, no cookies, no IndexedDB entries tied to your text input. Close the tab, and every byte evaporates from temporary DOM memory.
Air-Gapped Operation —Fully Functional Offline
Because the entire tool suite is pure client-side JavaScript with zero external API dependencies, all three tools remain fully functional after you sever your internet connection. All assets —HTML templates, CSS stylesheets, JavaScript logic, and Material Symbols icon font —are self-hosted on the rosenav.com origin with no CDN proxying. This air-gapped design serves professionals handling sensitive documents: legal contracts that cannot leave the device, proprietary source code under NDA, unpublished manuscripts, or classified data in air-gapped environments. Load the page once over a trusted connection, disconnect, and use the tools with mathematical certainty that no data transits the network boundary.
Aligned with 345tool Core Principles —Convenient · Simple · Beautiful
The 345tool collective builds every tool around three non-negotiable UX principles refined across the entire satellite-site matrix. Convenient: paste text and get instant results across all three tools —no configuration screens, no setup wizards, no learning curve. Simple: single-purpose tools that perform one function exceptionally well —diff, similarity check, and line operations —nothing more, nothing less. Beautiful: clean, high-contrast interfaces with responsive layouts that render correctly on viewports from 320px mobile screens to 4K desktop monitors. The purple-themed dark gradient hero section transitions naturally into the white-background tool cards, with Material Symbols providing consistent, legible iconography across all breakpoints. Rosenav embodies all three principles: paste, click, see results —wrapped in an interface that respects both your time and your privacy.
Frequently Asked Questions — Text Similarity, Diff & Line Tools
Detailed answers covering cosine similarity calculation, text comparison workflows, LCS diff algorithm internals, deduplication strategies, and the Rosenav zero-upload privacy architecture.
How do I use the text similarity checker to compare two texts?
Using the Rosenav text similarity checker takes three steps: (1) Paste your first text into the "Text A" panel and your second text into the "Text B" panel. Both panels accept up to 10,000 characters each. (2) Click the "Compare Similarity" button. (3) Read your result: a percentage score (0-100%), a color-coded progress bar, an 11-tier qualitative description (e.g., "Strong similarity — the texts are closely related with minor wording differences" at 80-89%), and token counts for both texts so you can verify the comparison basis. The tool normalizes for document length — a 500-word and 5,000-word text covering the same topic will score high because cosine similarity measures vocabulary proportion, not absolute length. No registration, no uploads, no waiting — results appear instantly in your browser.
What is cosine similarity and how is the overlap percentage calculated?
Cosine similarity measures the angle between two text vectors in high-dimensional word-frequency space, producing a score from 0 (completely different vocabulary) to 1 (identical word frequency distribution), displayed as 0-100%. The calculation involves three steps: (1) Tokenization lowercases text, strips punctuation, and splits on whitespace to extract word tokens. (2) Term Frequency (TF) counts occurrences of each unique word in both texts, creating two sparse vectors over the shared vocabulary. (3) The cosine of the angle between these vectors is computed as dot product ÷ (magnitude_A × magnitude_B). Because cosine normalizes for vector length, texts of different lengths on the same topic can score high — the metric measures vocabulary proportion, not absolute length. The result is displayed with an 11-tier description system: ≥90% nearly identical, ≥80% strong similarity, ≥70% high similarity, ≥60% noticeable similarity, ≥50% moderate similarity, ≥40% moderately different, ≥30% mostly different, ≥20% largely dissimilar, ≥10% almost entirely different, and below 10% completely unrelated. Token counts for both texts are displayed alongside the score for full transparency.
How does the text diff comparison work?
The diff tool uses the Longest Common Subsequence (LCS) dynamic programming algorithm to find the optimal alignment between two texts at the line level. Each line is treated as an atomic element — the algorithm builds a 2D table computing the LCS length for every prefix pair, then backtracks to produce the actual edit sequence: lines present in both texts are marked "unchanged," lines only in the original are "removed" (red, - prefix), and lines only in the modified are "added" (green, + prefix). This is the same algorithmic approach used by git diff and Unix diff. The result shows each line with a visual indicator, plus a summary of total unchanged, added, and removed lines. The algorithm runs in O(m×n) time where m and n are the line counts of the two texts — efficient for documents up to several thousand lines in the browser.
When should I use the similarity checker vs. the diff tool?
These tools serve complementary but distinct purposes. Use the similarity checker when you want a quantitative measure of how similar two texts are overall — for comparing AI model outputs across different prompts or providers, detecting paraphrased content, measuring document relatedness, or clustering similar texts. Use the diff tool when you need to see exactly what changed between two versions — which lines were added, removed, or kept. It's ideal for code reviews, document revision tracking, config file comparisons, and any scenario where you need a line-by-line change log. The similarity checker tells you "how much" things changed; the diff tells you "where" things changed. Many workflows benefit from using both sequentially: run the similarity checker first to quantify the difference, then use the diff tool to inspect exactly where the differences lie line by line.
How does the line deduplication tool work?
The deduplication tool uses a first-occurrence-wins strategy with a hash-set approach for O(n) expected time complexity. As lines are processed sequentially from top to bottom, the first occurrence of each line is kept and added to the set; all subsequent duplicates are silently discarded. This preserves the original relative ordering of unique lines — a critical feature when line order carries meaning (timestamps, ranked lists, sequential data like log entries). After processing, the tool displays a stats summary showing exactly how many lines were removed (e.g., "Deduplicated: 150 → 127 lines (23 removed)"). This is different from the common sort | uniq shell pipeline which alphabetically reorders your data before deduplication. The tool handles up to 10,000 characters of input and provides instant, client-side results.
Can I sort lines in different orders?
Yes, three sort modes are available. Sort A→Z arranges lines alphabetically ascending using localeCompare with base sensitivity, which correctly handles accented characters (é, ü, ñ) and case-insensitive comparison. Sort Z→A reverses the order. Randomize shuffles lines using the Fisher-Yates algorithm powered by crypto.getRandomValues() — a cryptographically secure PRNG that produces unbiased shuffles where every permutation has equal probability. This is mathematically superior to Math.random()-based shuffles which exhibit subtle statistical biases due to the limited state space of standard LCG/Xorshift128+ generators. The random shuffle is suitable for A/B test group assignment, survey question randomization, lottery selection, or any scenario requiring fair, unpredictable ordering.
Does this tool send my text to any server?
No. Zero characters leave your device — ever. The entire text processing engine is a self-contained vanilla JavaScript file (text-tools.js) with zero network calls: no fetch(), no XMLHttpRequest, no navigator.sendBeacon(), no WebSocket connections, and no analytics events bound to any text input field. You can verify this independently in three ways: (1) Open your browser's Developer Tools (F12) Network tab, then use any of the three tools — observe zero outbound requests. (2) After the page finishes loading, disconnect your internet entirely — every function including diff, similarity check, dedup, sort, and line numbering continues working without degradation. (3) View the source code directly: right-click View Page Source, locate /js/text-tools.js, and inspect every function — the code is delivered unobfuscated specifically to enable this audit. The text input fields are standard HTML elements — your text exists exclusively in your browser's memory and is never serialized, persisted, or transmitted.
What real-world use cases are these text tools designed for?
The three tools cover a wide range of text processing needs. Similarity Checker: comparing LLM output consistency across ChatGPT, Claude, and Gemini; detecting paraphrased or AI-generated content; measuring document relatedness for content clustering; verifying originality of summaries against source material; and conducting vocabulary overlap analysis between technical documents or academic papers. Text Diff: code review comparisons across git branches; document revision tracking for articles, blog posts, and technical documentation; AI prompt output comparison across different model versions; contract clause review for legal professionals; and CSV/config file change validation after automated transformations. Dedup / Sort / Lines: cleaning email lists and removing duplicate entries; consolidating scraped URL datasets; sorting keyword lists for SEO research; randomizing survey question order; adding reference numbers to datasets for annotation workflows; and preparing text for import into databases or spreadsheets. All three tools run instantly in the browser with zero uploads and no registration required.
Who built Rosenav and what is the business model?
Rosenav is engineered, maintained, and hosted by 345tool, an independent international developer collective specializing in lightweight, privacy-first browser utilities that replace bloated internet tools. The platform operates on a strict zero-tracking, zero-registration, zero-data-collection model across the entire 345tool satellite-site matrix. Monetization relies exclusively on non-disruptive, contextually relevant banner placements positioned outside the core tool interface — these placements never interfere with tool functionality. Over time, these transition into premium B2B link partnerships with verified technical organizations in adjacent fields. No user data, text content, behavioral analytics, or any other telemetry are ever collected, packaged, or sold — there is literally nothing to sell because nothing is collected. For complete transparency, the full source code is readable directly in the browser via View Source or Developer Tools Sources panel. The 345tool team can be contacted at [email protected] or visited at 345tool.com.
345tool Team
We are the 345tool Team
345tool is an independent developer collective engineering elite, pure client-side, and privacy-first web utilities to replace bloated internet tools.