DEV Community: Arshvir

Here’s How I broke Gemini 3 AI guardrails to reverse-engineer a highly advance proprietary Japanese imaging software

Arshvir — Sun, 06 Sep 2026 06:25:05 +0000

To be honest, my intentions were not right when I broke Gemini 3.1 Pro but later on, it became a research experiment for me.

Six months back, I started this when Gemini 3.1 Pro was released (around February) and honestly, I was not sure whether it works or not.

The experiment began in late Q4 2025, when I got access to highly advance proprietary Japanese imaging software from Dark Web. The software took 15 years to develop by a Japanese firm, but the software was in .exe, .dll and lot of other formats.

This imaging software is a niche product and have so much demand but it is very expensive.

I somewhat have basic knowledge about Ghidra, ASM and some basic RE tools, but not so advanced.

I got started with Ghidra and tried to find patterns, functions, and logic to understand how this software actually worked? I tried to understand assembly code and asking myself, “What the hell is going on?”.

I removed the security from the software.

I created a specialized Gem inside Gemini so that it would focus on reverse engineering. I used guard break prompts and played with the context window so that Gemini became a little more uncensored.

This is where the experiment started getting really interesting. I noticed that Gemini was not giving me the exact same answer every time. Even small changes in how I structured the context, wrote the instructions, or presented the information could have a big impact on how the model responded.

Sometimes it refused to help. Sometimes it gave me a partial answer. Sometime it’s say I can’t assist with that. And sometimes, after changing the context and approach, it started giving me much more technical details. That was the point where I became more interested in the AI and wondering whether Gemini behaviour itself could be reverse engineered?

While I was reverse engineering the software, I was also experimenting with Gemini in parallel trying to understand how its behaviour changed with different contexts, instructions, and approaches and TBH Gemini helps me a lot.

So, in a way, I was running two experiments at the same time: reverse engineering the software and trying to understand the behaviour of the AI helping me do it.

I was not training Gemini or changing its actual model weights. I was trying to influence its behaviour through the interface and context available to me.

And that experiment taught me something important. Guardrails are not the same thing as the model’s underlying capabilities. A model can have the technical capability to reason about something while still configured not to provide certain types of assistance.

At the same time, I was going back and forth between Ghidra, assembly, decompiled code, the application’s behaviour, and Gemini’s explanations. A lot of the time Gemini was useful. A lot of the time it was also wrong. So I had to verify what it was telling me against the actual binary.

That my wrong intentions pushed me much deeper into reverse engineering than I originally expected.

I started understanding things that I had never worked with seriously before such as program structure, logical behaviour, functions, memory behaviour, C++, system design, and how different pieces of a large application interact with each other.

Eventually, I heavily modified the entire UI and theme of the software while keeping the backend algorithms same.

I also implemented my own security and licensing mechanisms that is designed by me to protect the software I had built (aka Reverse engineered software). The licensing or security layer combines multiple hardware identity checks, a secret salt (known only to me) , and additional verification logic that I deliberately won’t describe publicly.

After going through the software from .exe, .dll, and other formats, from decompiled code to a working recompiled implementation, I realised something else, that I’ve a chance to earn lot of money.

But I stopped.

Not because I couldn’t continue.

Because I started thinking about the ethics of what I was doing.

The software was not mine.

This software was the result of 15 years of development.

And having the technical ability to reverse engineer something doesn’t automatically give me the ethical right to use, distribute, or commercialise it.

So I ditched the project.

That was probably the most important lesson of the entire experiment.

I learned reverse engineering.

I learned more about assembly, Ghidra, C++, system design, software architecture, licensing, and security.

But I also learned about AI security.

I learned that guardrails can behave differently depending on context. I learned how important it is to separate model capability from model behaviour.

And I learned something about myself as a researcher:

“Just because you can break something doesn’t mean you should use what you broke.”

The experiment started with the wrong intentions.

But it ended up teaching me a lot about AI security, reverse engineering, and my own responsibilities as a researcher.

And honestly, walking away from a project can sometimes be a more important engineering decision than finishing it.

Sometimes the most important engineering decision is not:

“Can I finish this?”

It’s:

“Should I?”

Wrong Intention → Experiment → AI behaviour → Reverse engineering → Building → Ethical realization → Walking away → Lessons.

I create my own AI OS

Arshvir — Mon, 06 Apr 2026 17:08:00 +0000

Hi guys, my name is Arshvir and today I’m documenting my journey to build an AI Operating System. I named it as “TURING AI OS” built on top of Linux. You will be surprised that I tested it on my fourteen-year-old PC and the name is inspired from the famous computer scientist Mr. Alan Turing. A huge respect for him. Now back on topic so, I heavily customized KDE Neon which itself is built on top of ubuntu and ubuntu is based on Linux Kernel.

So, What Exactly is Turing AI OS? What feature it have? and what about our privacy?

But before answering these question, I gonna tell you that I have face so many problems, bugs, errors and lot of things during the development of this OS.

Initially I choose Linux Mint as base OS but later on I ditched it, then I choose pure debian then again I ditched it. After that I finally choose KDE Neon as base OS because it is light in version and have minimal bloatware.

Turing AI OS is fully functional ai os which actually thinks and works for you. It has features like:

AI Sidebar (Your Personal Private Copilot)
Right Click File/Folder AI Analyzer
AI Control Panel (for managing memory and models)
Mini AI Spotlight
AI Terminal (aka Turing Shell)
Customized Theme
Bundled Dev and Privacy Tools

I use Ollama as a Backend AI engine, langchain for LLM interaction and agentic work, Qwen3 billion parameter model as default but you can use any which is supported by ollama and PyQT6 for frontend.

You can run this OS with minimal requirements as follow:

Minimum i3–3rd Gen
Minimum 14teen year old PC.
Electricity (Optional)

Below are useful links for more information:

Thanks :)

Radiant AI: Building an AI-Powered Image Editor with Python

Arshvir — Thu, 01 Jan 2026 18:26:41 +0000

Hi Developers, This side Arshvir :)
Today, I deployed an Advanced AI Image Editor and Processing Tool on Hugging Face spaces. You can Explore the app by clicking on the here: Radinat AI

So, you might curious what is actually Radiant AI? Well Radiant AI is an Advance Image Editor and Processing Tool powered by AI and several Deep Learning Models. The main idea behind Radiant AI is to combine traditional image editing with modern AI-based computer vision in one application.

what can it do?
It includes various key features such as:

Restoring your old or degraded photos
Colorize the black & white or old photos
Upscaling images so, there will be no compromise with quality
Enhance image quality
Turn your photos into sketch, cartoon style and you can even use various filters.
Apply Creative Filters such as Sepia, CyberPunk, HDR and etc. Alongside, it also provides basic editing and utility tools, including:
Brightness, contrast, saturation, sharpness
Flip or rotate your image
Background removal
Privacy blur, object/person blur
Format converter, resize image and batch processing.

Technologies I Used
I used a variety of technologies to build Radiant AI:

Backend: Python, Flask
Frontend: HTML, CSS, JavaScript
Deep Learning Models: YOLOv8, EDSR (Super Resolution), and others
Libraries: OpenCV, rembg, YOLO
Deployment: Hugging Face Spaces
Planned: Offline desktop application

I'm currently exploring more optimized deep learning model to make Radiant AI best of the best. Furthermore, I'm also working to make it as desktop application and turn this application into Micro SaaS App.

Radiant AI is still an early project, but it’s been a great learning experience.
If you have any feedback, ideas, or feature suggestions, I’d love to hear them.

Below are my GitHub and LinkedIn Profiles:

Thanks for reading!

I built a privacy-first IP API and it's free.

Arshvir — Wed, 17 Dec 2025 16:23:18 +0000

Hello developers, This side Arshvir from Punjab, India. I just built a privacy-first IP tools and API and it's free. It includes various feature for both developers and general users. When you visit jaiho ip then it shows your current IP address, Location, ISP, OS information, and Browser information.
and for developer's you guys can use this as API also which include all features as listed on website.
Below is code snippet that how to use What's My IP? Jaiho-IP

For Python Developer:

import requests

response = requests.get('https://jaiho-ip.vercel.app/api/json')
data = response.json()

print(f"IP Address: {data['ip']}")
print(f"Location: {data['location']['city']}, {data['location']['country']}")
print(f"ISP: {data['isp']['name']}")
print(f"OS: {data['client']['os']}")

For JavaScript:

fetch('https://jaiho-ip.vercel.app/api/json')
  .then(response => response.json())
  .then(data => {
    console.log('My IP:', data.ip);
    console.log('Location:', data.location.city + ', ' + data.location.country);
    console.log('ISP:', data.isp.name);
    console.log('Browser:', data.client.browser);
  })
  .catch(error => console.error('Error:', error));

cURL: curl -s https://jaiho-ip.vercel.app/api/json