DEV Community: Sreevatsa Rajesh

Trace-X, image forensics

Sreevatsa Rajesh — Mon, 02 Nov 2026 15:21:22 +0000

I Built TRACE-X: Exploring Digital Image Forensics Beyond Basic Tampering Detection
Images are shared across social media, messaging platforms, and websites every day.
But what happens to forensic evidence when an image gets compressed, resized, cropped, or edited before being shared?
That's the question that led me to build TRACE-X 2.0 — Transformation-Resilient Adaptive Cross-platform Evidence Engine.

The Problem

Traditional image-forensics techniques can become less reliable when images undergo common transformations.
A forensic signal that is visible in an original image might weaken or change after JPEG compression, resizing, or cropping.
I wanted to explore whether combining multiple forensic signals could provide more useful evidence under these conditions.

What is TRACE-X?

TRACE-X is an experimental digital image-forensics framework that combines multiple image-analysis techniques into a single evidence-fusion pipeline.
Currently, it explores four forensic signals:
Error Level Analysis (ELA): Examines differences introduced by JPEG recompression.
Discrete Cosine Transform (DCT): Analyses frequency-domain characteristics.
Noise Residual Analysis: Examines residual patterns after image smoothing.
JPEG Grid Analysis: Examines discontinuities around JPEG block boundaries.
These signals are combined using a heuristic, profile-conditioned fusion mechanism.
The system generates:
Combined evidence maps.
Evidence overlays.
Exploratory threshold masks.
Signal disagreement visualisations.
Machine-readable JSON reports.
Human-readable HTML reports.

Testing Transformation Robustness

I also implemented experiments involving:
JPEG compression at different quality levels.
Image resizing.
Cropping.
Gaussian blur.
The objective is to understand how different forensic signals behave when the same image undergoes these transformations.

Tech Stack

Python
NumPy
OpenCV
Pillow
SciPy
Matplotlib
Streamlit
Pytest

What's Next?

TRACE-X is still an experimental research project.
My next goals are:
Integrate established image-forensics datasets.
Evaluate localisation using ground-truth manipulation masks.
Compare against existing forensic baselines.
Explore learned transformation profiling.
Develop and validate adaptive evidence fusion.
Investigate cross-dataset generalisation.
I am particularly interested in understanding whether transformation-aware evidence fusion can improve the localisation of manipulations compared with fixed forensic approaches.

Explore the Project

GitHub: https://github.com/sreevatsarajesh/Trace-X

I welcome feedback, suggestions, research references, and contributions from anyone working in computer vision, cybersecurity, or digital forensics.
If you've worked on image manipulation detection or forensic localisation, I'd love to hear your thoughts.
Building, testing, learning, and improving. 🚀

Python #DigitalForensics #ComputerVision #Cybersecurity #MachineLearning #OpenSource #ImageProcessing #Research

Wraith - A Ghost in your terminal

Sreevatsa Rajesh — Wed, 28 Oct 2026 15:35:23 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

What I Built

What if

Demo

https://drive.google.com/file/d/1mwpEO69gZUw7b9c-xYe-d7hL8LkPO7U-/view?usp=drive_link

Code

https://github.com/sreevatsarajesh/Wraith-

How I Built It

Wraith uses Qwen 2.5 3B, an open-weight language model served locally through Ollama.
The four spirits each have a distinct identity:
Geocities — a relic of the old web, guestbooks, webrings, and forgotten homepages.
Fortran — an echo from the age of punch cards and mainframes.
Deleted File — a voice from things that disappeared but left traces behind.
Unix Daemon — a quiet keeper of processes, logs, and system secrets.

The web interface lets you choose a spirit, send command text for a reaction, check the local API connection, and explore recent memories. The interface is designed to observe command text rather than execute arbitrary commands.

Why Does Open Innovation Matter?

Wraith depends on the freedom to run an open-weight model locally built

The Spirit of It

I wanted to capture a very specific feeling: opening an old terminal late at night and imagining that something has been there longer than you have.
The old internet had personality which I wanted to bring back

Prize Categories

Best Use of Entire — sharing the agent session behind Wraith's development, provided the session is recorded and linked using the challenge's required workflow.

THE TERMINAL IS WATCHING

Codebase X-Ray

Sreevatsa Rajesh — Wed, 21 Oct 2026 17:17:18 +0000

I Built Codebase X-Ray: Visualizing Python Codebases and Their Dependencies

Have you ever opened an unfamiliar Python repository and spent more time figuring out how its files connect than actually understanding the code?

That was the problem I wanted to tackle with Codebase X-Ray.

It's a developer tool I'm building to analyze Python repositories and turn their structure and dependencies into an interactive visual graph.

Why I Built It

When working with a multi-file project, understanding the relationships between modules, functions, classes, and imports can be difficult. Jumping between files isn't always the best way to understand the overall architecture.

I wanted a tool that could provide a visual starting point for exploring an unfamiliar codebase.

How It Works

Codebase X-Ray combines static code analysis with an interactive frontend.

1. Python AST Analysis

The backend uses Python's built-in ast module to inspect source files without executing them.

It extracts information such as functions, classes, and imports, which forms the basis of the repository's structural representation.

2. Dependency Extraction

The scanner identifies import relationships between files and builds dependency information that can be visualized.

Dynamic imports and some external dependencies can be difficult to resolve statically, so the results aren't intended to represent every possible runtime relationship.

3. Interactive Graph Visualization

The frontend uses React and React Flow to display relationships between code elements. Dagre helps arrange the graph layout.

Instead of navigating every file individually, developers can explore the structure visually.

4. Technology Stack

Python for AST-based analysis
FastAPI for the backend API
React and Vite for the frontend
React Flow for graph visualization
Dagre for graph layout

Codebase X-Ray in Action

1. Repository Scanning and System Metrics

The first step is scanning a repository. Codebase X-Ray accepts a GitHub repository URL or a local directory path and analyzes the Python source files.

Once scanning completes, the dashboard displays key metrics, including the number of Python files discovered, import relationships extracted, symbols identified, and parsing errors encountered.

In this example, the scanner processed 23 Python files, identified 15 import relationships, extracted 48 symbols, and reported zero parsing errors.

2. Interactive Dependency Graph

After scanning, the extracted information is presented as an interactive dependency graph. Each node represents a code element or file in the visualization, while the connecting edges represent import relationships.

Files are organized into color-coded project groups, making it easier to distinguish different parts of a repository and understand how they connect.

The graph supports navigation and zooming, allowing developers to explore the structure of a codebase visually instead of relying entirely on manual file-by-file inspection.

3. Inspecting Individual Files

The graph provides an overview of the repository, but sometimes you need to focus on a particular file.

Selecting a file opens the file inspector, which displays its path, project group, and available dependency information. In this example, the inspector shows app.py and its outgoing import to utils.py.

This makes it easier to investigate how a file depends on other modules and navigate the codebase with more context.

What's Next?

I'm continuing to improve Codebase X-Ray, particularly its ability to make larger codebases easier to explore.

I'm also considering optional local AI integration through Ollama to generate code summaries and explain dependency relationships without making AI a requirement for the core scanner.

Check Out the Project

GitHub repository: https://github.com/sreevatsarajesh/Codebase_XRay

I'd Love Your Feedback

What would you want to see in a codebase visualization tool?
Which parts of understanding an unfamiliar repository take you the most time?
Would AI-generated explanations of code relationships be useful, or would you prefer purely static analysis?

Thanks for reading!