A lineage intelligence platform for detecting code ancestry, rethinking how original work is credited in collaborative software ecosystems.
In the sprawling, interconnected world of modern software development, every line of code has a story—a lineage that stretches back through forks, merges, rewrites, and references. Traditional plagiarism detectors treat code as static text to be compared, but that approach is fundamentally flawed. They miss the subtle mutations, the refactored logic, the architectural shadows that persist even when every variable name has changed.
VerdantTrace is not another similarity scorer. It is a provenance mapping engine that reconstructs the evolutionary path of code fragments across repositories, identifying not just identical strings but functional descendants—code that has been transformed, obfuscated, or rewritten while retaining its original computational DNA. It's built for educators who want to foster genuine understanding, for maintainers who need to trace licensing conflicts, and for researchers who study how programming ideas propagate through communities.
Standard detection tools operate on a binary premise: either the code is the same or it isn't. This simplistic view fails in the real world where:
- Students rename variables to evade detection, but the control flow remains structurally identical
- Developers copy a Stack Overflow solution and adapt it to their context, creating a derivative work
- Open-source projects fork and diverge, with attribution requirements getting lost in the process
- Malicious actors deliberately obscure their copying through whitespace manipulation and meaningless reordering
VerdantTrace moves past the text itself. We analyze the semantic fingerprint of algorithms—the decision trees, loop invariants, and data flow patterns that define what a piece of code actually does, regardless of how it's written.
Instead of comparing bytes, we convert code into a high-dimensional semantic vector space where:
- Syntax Abstract Syntax Trees (ASTs) are normalized to remove formatting noise
- Control Flow Graphs (CFGs) capture the logic skeletons independent of expression
- Data Dependencies trace how information moves through variables and functions
- Domain-Specific Idioms recognize common patterns (e.g., swapping values, iterating collections)
These layers are weighted and combined into a semantic hash that remains stable under superficial changes but shifts dramatically when the underlying logic changes. This is akin to comparing two images by their structural composition rather than their pixel values—a cat drawn in charcoal and a cat photographed in color are still both cats.
VerdantTrace doesn't just flag matches; it builds a visual ancestry tree for each code fragment. When you submit a codebase, the system:
- Identifies every unique algorithmic motif
- Maps these motifs to known upstream sources (public repositories, submission histories, licensed libraries)
- Constructs a directed graph showing how code from source A influenced code in submission B, which then diverged into C and D
This turns a binary "copy/not copy" verdict into a rich narrative of intellectual influence, enabling educators to make informed, defensible judgments.
Interactive, zoomable maps that display the complete evolutionary history of code in your repository, color-coded by source, with severity ratings for each derivation.
Score each flagged section with a Plagiarism Probability Index (PPI) that accounts for:
- The amount of code involved
- The originality of the algorithm
- The transformation distance from the original
- Whether the code is a generic pattern vs. a specialized implementation
Supports all major VCS formats (Git, Mercurial, SVN) and code hosting platforms through a unified API. Works with classroom LMS systems, CI/CD pipelines, and standalone research datasets.
Out-of-the-box support for 15 programming languages including Python, Java, JavaScript, C++, Go, Rust, Ruby, and others. The semantic fingerprint engine treats each language as a dialect of the same computational substrate.
For ongoing projects, VerdantTrace can be configured as a webhook service that automatically scans new commits and forks, alerting you to potential licensing violations or academic integrity issues in real-time.
Designed specifically for educational institutions with:
- Batch submission processing
- Per-student historical profiles
- Custom similarity thresholds per course
- Anonymized reporting that adheres to FERPA and GDPR requirements
Sophisticated countermeasures against common evasion tactics:
- Detects hash flips and random symbol generation
- Identifies dead code insertion designed to break tokenization
- Recognizes equivalent control structures (e.g.,
forvs.whileloops performing identical iterations) - Unmasks whitespace obfuscation through AST reconstruction
- Modern web browser (Chrome 112+, Firefox 110+, Safari 16+)
- Node.js runtime environment (v18 or later) for self-hosted deployments
- 4GB RAM minimum for processing large repositories
- Initialize the environment by installing the dependency bundle from the package registry.
- Configure your data source by adding connection credentials for your code repositories or learning management system.
- Run your first analysis by pointing VerdantTrace at a directory or repository URL. The system will take a few moments to build the semantic index.
- Review the provenance map in the interactive dashboard, filter by risk level, and drill down into specific code sections for detailed comparison views.
For a guided walkthrough, refer to the Tutorials section in our documentation portal, where you'll find video demos and hands-on exercises.
VerdantTrace offers granular control to match your unique requirements:
- Detection Sensitivity: Adjust the threshold from "Hyper-Focused" (catches only near-identical copies) to "Forensic" (catches all plausible derivations)
- Language Prioritization: Weight certain languages more heavily in mixed-language codebases
- Reference Datasets: Import your own curated set of known solutions (e.g., all previous year's student submissions) to build a proprietary baseline
- Output Formats: Export reports in PDF, JSON, CSV, or as structured data for SPSS/R analysis
We believe that ethical code attribution is a collaborative effort. That's why VerdantTrace ships with:
- 24/7 Technical Assistance: Our support team is available around the clock via multi-channel ticketing, with an average first-response time under 30 minutes.
- Semantic Scholar Forums: A moderated community space where educators share detection strategies, pedagogical approaches, and data analyses.
- Localized Documentation: Full user guides, API references, and troubleshooting FAQs in English, Spanish, German, French, Japanese, and Mandarin.
- University Partnership Program for institutions that want to co-develop features or participate in academic research.
A computer science department with 2,400 students per semester reduced their manual plagiarism review time by 78% after adopting VerdantTrace. Instead of eyeballing similarity reports, faculty now spend their time in meaningful conversations with students about original thinking and proper attribution.
A major Linux distribution project integrated VerdantTrace into their commit review process. They successfully identified 14 instances of GPL-licensed code being used in proprietary modules, saving a potentially costly lawsuit and preserving their regulatory compliance.
A Fortune 500 company uses VerdantTrace to assess whether internal code has been derived from open source libraries with incompatible licenses, ensuring that their patent filings aren't compromised by undisclosed third-party contributions.
VerdantTrace is a decision support tool—it flags potential issues and provides evidence, but it is not a substitute for human judgment. Plagiarism, especially in code, is a nuanced concept that depends on intent, context, and institutional policy.
Our software does not make legal determinations or academic verdicts. The Probability Index (PPI) is a statistical correlation measure, not a proof of wrongdoing. Institutions and organizations using VerdantTrace are responsible for:
- Establishing their own review procedures
- Ensuring compliance with applicable privacy laws in their jurisdiction
- Interpreting the results within the framework of their code of conduct
We strongly recommend that any automated flag be manually reviewed by qualified personnel before any action is taken. False positives can occur, especially with generic, idiomatic code patterns that naturally emerge independently in different projects.
VerdantTrace is released under the MIT License. You are free to use, modify, and distribute this software in both personal and commercial settings, provided that the original copyright notice and permission statement are included in all copies or substantial portions of the software.
The software is provided "as is," without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose, and non-infringement. In no event shall the authors or copyright holders be liable for any claim, damages, or other liability arising from the use of this software.
VerdantTrace is built on a microservices architecture that scales horizontally:
| Component | Responsibility | Technology Stack |
|---|---|---|
| Ingestion Gateway | Normalizes input from various repositories | Node.js, gRPC |
| Semantic Engine | Computes fingerprints and builds graph relationships | Python, Rust core |
| Graph Database | Stores provenance relationships | Neo4j |
| Query Service | Provides REST/GraphQL APIs for external requests | GraphQL, Express |
| Visualization Frontend | Interactive maps and dashboards | React, D3.js |
Each service can be deployed independently, enabling you to scale only the components you need.
We welcome contributions that align with our mission of promoting fair attribution in the software ecosystem. Whether you're a developer interested in parser optimizations, a UX designer focused on the dashboard experience, or an educator with domain expertise, there's a place for you here.
- Feature Requests: Suggest improvements or novel detection strategies via issue tracking
- Language Packs: Help extend semantic analysis to additional programming languages
- Research Collaboration: Partner with us on academic studies about code evolution and reuse patterns
- Detailed Methodology Paper: "A Semantic Approach to Code Provenance Detection"
- API Reference v2.3
- Deployment Guide for Air-Gapped Environments
- Case Studies in Academic Integrity (Quarterly publication)
For an overview of our roadmap, including plans for machine learning–enhanced detection and offline mobile support, see the project wiki.
VerdantTrace — because every line of code has a story, and that story deserves to be told with clarity and respect.