01 // REVERSE_ENGINEERING_CORE

System & Architecture Inference

Deconstruct any public surface into clean database schemas, REST APIs, technology stacks, and production implementation blueprints.

MODEL //
++++
02 // ARCHITECTURAL_SPECIFICATIONS

From Raw Surface to Complete Blueprint

Reparse decodes product intent, reverse-engineers underlying data models, and reconstructs purified production-grade components.

++
01 /

Schema Inference

Instantly reverse-engineer database collections, fields, and relationships from any public application.

MODULE_OKVERIFIED
++
02 /

API Structure

Extract REST API endpoints, expected request bodies, and response structures seamlessly.

MODULE_OKVERIFIED
++
03 /

Design System UI

Generate detailed prompts for Figma or Google Stitch to recreate the frontend UI aesthetics.

MODULE_OKVERIFIED
++
04 /

Competitor Matrix

Automatically map out competitors, perform gap analysis, and discover missing features.

MODULE_OKVERIFIED
++
05 /

Tech Stack Discovery

Identify the frontend frameworks, backend languages, and DevOps tools powering the platform.

MODULE_OKVERIFIED
++
06 /

Security & Performance

Analyze authentication mechanisms, RBAC, and SEO/performance optimization strategies.

MODULE_OKVERIFIED
++
07 /

HTTrack Mirroring Engine

Recursive depth-controlled crawling, binary media downloads, robots/sitemap discovery, and offline URL rewriting.

MODULE_OKVERIFIED
++
08 /

CSS Used Clean Engine

Purifies stylesheets by matching active DOM elements, keyframe animations, :root variables, and media queries (-70%+ size reduction).

MODULE_OKVERIFIED

One sentence. 45 seconds.

I asked Jarvis out loud, “How does this site do that scroll?”

Then I didn't touch a thing.

++++
0s

Opens the site

A clean browser. No logins, no cookies, nothing of yours.

INSPECT_STEP
++++
3s

REA starts watching

Jarvis scrolls the page by himself so every effect fires.

INSPECT_STEP
++++
11s

REA reads the code

And finds the tools the designers used, hiding inside.

INSPECT_STEP
++++
17s

Lines up the evidence

Every file, every library, every effect, with proof.

INSPECT_STEP
++++
45s

Saves the teardown

A spoken answer, plus a note in his brain with a rebuild recipe.

ACTIVE_TELEMETRY
++++
45s
[REBUILD_RECIPE_READY]
Saves the teardown
ELAPSED: 45.00s / 45.00s

> Synthesized standalone TypeScript / GSAP component for immediate paste...

EVIDENCE_FINDINGS_LOG
Full reproduction recipe generated
100% clean standalone implementation
Evidence archived to persistent audit index
SYNTHESIZED_REBUILD_RECIPE
// Rebuilt Scroll Effect Recipe (GSAP + ScrollTrigger)
import gsap from 'gsap';
import { ScrollTrigger } from 'gsap/ScrollTrigger';
gsap.registerPlugin(ScrollTrigger);

export function initDeconstructedScroll(targetEl: HTMLElement) {
  return gsap.timeline({
    scrollTrigger: {
      trigger: targetEl,
      start: 'top 80%',
      end: 'bottom 20%',
      scrub: 1.2,
      markers: false,
    }
  }).fromTo(targetEl, 
    { y: 60, opacity: 0, scale: 0.98 },
    { y: 0, opacity: 1, scale: 1, ease: 'power2.out', duration: 1 }
  );
}

Not a guess. The recipe.

Deep telemetry separates verified client facts from speculation. Every engine, texture, and animation trick identified.

++++
THE 3D ENGINE

Three.js

Draws the entire 3D world you see on the page.

version 165
++++
THE CHOREOGRAPHER

GSAP

Times every move, with hand-made easing curves for that buttery feel.

version 3.12.5
++++
THE MOVIE CAMERA

Blur, glow, polish

Depth of field and bloom, the same effects a real film lens gives you.

post-processing
++++
THE WEIGHT

95 files • 14.7 MB

10.5 MB of squeezed 3D textures, 2.8 MB of music, and only 0.5 MB of actual 3D models.

every file logged
++++
THE BIG REVEAL

It doesn't scroll

The page is one screen tall. Your scroll wheel moves a camera through a 3D world instead.

the trick
++++
THE SECRET FILE

“scroll data”

A 1.2 MB image with that name. Jarvis's guess: part of the animation is stored inside a picture.

flagged as a guess
++++
ARCHITECTURAL_WORKFLOW // THE X-RAY KIT

How REA & Reparse Deconstruct Websites

4-STAGE PIPELINE
STEP 1

You ask

“How does this website do that?”
QUERY INPUT
STEP 2

Your AI

Claude Code, Cursor, or Jarvis plans the reverse-engineering investigation, then delegates tasks to REA.

AGENT ORCHESTRATION
STEP 3 • THE X-RAY KIT

REA / ReparseActive

  • Watches the site run
  • Reads the code it downloads
  • Logs every file it loads
X-RAY ENGINE
STEP 4

Evidence

  • What it's built with
  • How the effect works
  • What it couldn't see
SYNTHESIS COMPLETE
THE PROOF COMES BACK →Evidence feeds back into the AI to write clean, working implementations.
FAIL-CLOSED•LOCAL EXECUTION•NO UPLOADS

No hacking. Reparse only reads what a website already sends to your browser, the same view any web developer has. Point it at public websites, open-source code, and things you own.

++++
03 // PIPELINE_EXECUTION

Autonomous System Deconstruction

Input any target endpoint or supply an architectural brief. Our distributed ingestion engine analyzes client payloads, extracts state structures, and reconstructs clean, standalone components in milliseconds.

[AST_STACK]

Automated Framework & Tooling Detection

Detects runtime libraries, CSS architectures, and bundlers

[DATA_GRAPH]

Relational Entity Inference

Rebuilds database schemas with foreign key mappings

[ROADMAP]

Architectural Roadmap & Engineering Milestones

Generates step-by-step sprint breakdown and execution plan

CONSOLE // TELEMETRY
LIVE_SYNC
SCHEMAS
REST_APIS
COMPONENTS
05 // FIELD_VERIFICATIONS

Engineered for Technical Builders

Verified evaluations from engineering leads and system architects utilizing Reparse in production workflows.

++
[VERIFIED_DEPLOYMENT]

“Reparse has completely changed our competitor analysis workflow. Instead of spending weeks clicking through a competitor's app manually, we just paste the URL and get their entire feature breakdown and schema instantly. Bhai, this tool is next level.”

Rahul S.Lead PM, Bangalore
++
[VERIFIED_DEPLOYMENT]

“The API endpoint inference is shockingly accurate. It correctly identified the REST structure and payload formats for a complex fintech platform we were benchmarking against. Saved me hours of manual network inspection. Highly recommended for devs in the startup ecosystem.”

Sneha T.Senior SDE, Pune
++
[VERIFIED_DEPLOYMENT]

“I used Reparse on a market leader in our niche. It gave me a complete MVP roadmap, tech stack recommendations, and even estimated development costs in INR. It's literally like having a principal engineer and PM working with you.”

Kartik V.Startup Founder, Gurugram
++
[VERIFIED_DEPLOYMENT]

“The Design System extraction is brilliant. It gives me exactly what I need to start building a Figma library that matches a competitor's aesthetic, complete with color palettes and typography rules. Ekdum solid functionality.”

Priya D.UI/UX Designer, Hyderabad
04 // PROVISIONING_TIERS

Predictable Infrastructure Pricing

Select the compute and reverse-engineering capacity aligned with your engineering workload.

++
TIER_01

Free Developer

Perfect for exploring basic architecture and small projects.

$0/month
  • Up to 5 analysis runs per day
  • Basic feature extraction
  • Frontend tech stack detection
  • Community support
++
RECOMMENDED
TIER_02

Pro Architect

Deep insights for product managers and senior engineers.

$49/month
  • Unlimited analysis runs
  • Full Database Schema extraction
  • REST API endpoint inference
  • Competitor comparison matrix
  • Export to Markdown & ZIP
++
TIER_03

Enterprise Solutions

Scale your architecture analysis across the whole organization.

$199/month
  • Everything in Pro
  • Custom AI model selection
  • Figma/Stitch UI prompts
  • API access to analysis engine
  • Dedicated account manager
06 // ARCHITECTURAL_KNOWLEDGE_BASE

System Documentation & Protocols

Technical insights into client-side extraction, LLM pipeline reasoning, and safety boundaries.

Reparse uses an advanced multi-step pipeline. It first crawls the public DOM, extracting metadata, semantic tags, and linked resources. It then feeds this structured data into specialized LLMs (like Qwen 2.5 Coder) configured as architectural experts to infer the backend logic, API structure, and database schema based on observed frontend behaviors and data shapes.
No reverse-engineering tool can see the actual backend code. The generated schemas are 'highly probable inferences'. Reparse looks at the data rendered on the page, the network requests (if inferable from scripts), and industry best practices to construct an architecture that would logically support the application's features.
Reparse relies on server-side scraping. If a site has aggressive anti-bot protections like Cloudflare Turnstile, the initial scrape might be blocked. However, Reparse will automatically fallback to purely LLM-based knowledge retrieval if the scraper fails, ensuring you still get an architectural breakdown.
By default, we route requests through OpenRouter's free tier for maximum stability. However, you can select specialized models from the dropdown like Qwen 2.5 Coder (best for technical specs), Gemma 2, or Llama 3.2 depending on your specific needs.
Yes! Once an analysis is complete, you can click the 'Download .ZIP' button at the bottom of the blueprint. This packages the entire analysis into neatly organized Markdown files (SRS, PRD, Database Schema, API Docs) ready to be dropped into GitHub or Notion.