Automated Project Evaluation Hub Plagiarism Detection

Grade code, catch plagiarism and alert faculty in real time Auto-grade code and catch plagiarism in one workflow One hub to grade student code and check its originality

Comment

Inspiration

In every semester, faculty review hundreds of student projects and programming assignments by hand. They run each program on a personal machine, skim reports for copied text, and compare submissions side by side. It is slow and inconsistent, and the plagiarism usually shows up only after marks are already given.

Generative AI made this worse. A student can now produce working code or a polished report in minutes, and none of it matches an earlier submission, so classic similarity checkers miss it. I wanted one place where a submission is graded and checked for originality, with faculty alerted straight away.

What it does

Automated Student Project Evaluation Hub is a web platform for students, faculty guides and admins.

  • Auto-evaluation: faculty create coding assignments with hidden test cases. Student code is run against them and graded instantly. Supported languages: C, C++, Java, Python, JavaScript, Go, Ruby and Rust.
  • Safe execution: every run happens in a throw-away Docker container with a 128 MB memory limit, 0.5 CPU, 20 processes, no network and a 10 s timeout.
  • Code plagiarism detection: a Winnowing fingerprint engine finds copied logic even when variables are renamed or comments are changed, and shows the matched regions.
  • AI-powered checks (AI + Education): Gemini 2.5 Flash with Google Search grounding scans project reports for text copied from the web (a warning is raised above 35% similarity), and estimates how likely a piece of code is to be machine-generated.
  • Real-time alerts: when a threshold is crossed, faculty and the student are notified instantly over Socket.IO.
  • Project management: teams upload reports and presentations, and guides review and grade them with rubrics.

Target users: students, faculty guides and administrators in colleges and universities.

How I built it

Stack: React + Vite, Tailwind CSS and Framer Motion on the frontend; Node.js, Express, MongoDB (Mongoose) and Socket.IO on the backend; JWT for role-based access; Docker for sandboxing; Gemini API for the AI checks.

The plagiarism engine works in these steps:

  1. Normalise the code: remove comments, standardise whitespace, replace numbers with LITERAL and identifiers with VAR, but keep keywords such as if, for and while. This keeps the logical skeleton of the program.
  2. Tokenise and form overlapping k-grams of tokens (k = 5).
  3. Hash each k-gram with a rolling hash into a 32-bit integer.
  4. Winnow: slide a window of $w$ hashes over the sequence and keep the minimum in each window as a fingerprint. Any shared run of at least $k + w - 1$ tokens is guaranteed to share a fingerprint.
  5. Compare two submissions $A$ and $B$ using the Jaccard similarity of their fingerprint sets $F_A$ and $F_B$:

$$J(A,B) = \frac{|F_A \cap F_B|}{|F_A \cup F_B|}$$

The final score blends both views:

$$S = 0.4\,S_{\text{text}} + 0.6\,S_{\text{structure}}$$

If $S$ exceeds the assignment's threshold, Socket.IO events alert the faculty member and the students involved.

Challenges I ran into

  • Renamed variables: plain text matching is fooled by simple edits. Normalising identifiers and literals before hashing fixed this, and weighting structure at 60% made scores more reliable than text alone.
  • Running untrusted code: student code can loop forever or use too many resources. I solved it with ephemeral containers and strict limits, plus a local fallback for development when Docker isn't available (it is less isolated, so it is not meant for production).
  • AI detection is a probability, not proof: LLM-based checks can give false positives. So the hub flags submissions for faculty review rather than punishing students automatically.
  • Scaling comparison: comparing every pair of submissions grows as $O(N^2)$, which gets slow for large batches.

What I learned

How fingerprinting algorithms like Winnowing work in practice, how to isolate and limit untrusted code with Docker, how to design role-based real-time systems with Socket.IO, and how to use LLMs carefully as a decision aid instead of a judge.

Real-world impact

Faculty spend less time running and comparing code by hand, grading becomes consistent across a whole batch, and students get quick feedback. Plagiarism is caught early, including AI-generated content, and academic integrity improves without sending student work to outside services.

What's next

  • Fingerprint bucketing to avoid comparing every pair of submissions
  • Tuning the AI-code detection on a labelled dataset
  • Cross-semester comparison and analytics dashboards
  • Integration with learning management systems

Built With

Share this project:

Updates

Submission history