DEV Community: BHUVANESH M

MaskAgent : A Privacy-First Browser Agent That Protects Your Data Before AI Sees It

BHUVANESH M — Sun, 27 Sep 2026 05:10:58 +0000

MaskAgent is a privacy-first browser agent designed to perform
intelligent browser automation while keeping sensitive user data
protected on the device.

Smart India Hackathon 2026 · Problem Statement SIH26171

🔗 Project: https://bhuvanesh-m-dev.github.io/maskagent/
🔗 GitHub: https://github.com/bhuvanesh-m-dev/maskagent
▶️ Demo: https://youtube.com/watch?v=_rl1w6US6_U

The Problem: AI Browser Agents Can See Too Much

AI browser agents are becoming capable of understanding webpages and
performing tasks such as clicking buttons, entering information,
scrolling, and navigating websites.

But there is a privacy problem.

A webpage may contain:

Names and addresses
Email addresses and phone numbers
Account information
Financial information
Personal identifiers
Other confidential information

If an AI system receives the raw webpage or screen content, sensitive
information may cross the privacy boundary before the agent can reason
about the task.

MaskAgent approaches this problem differently:

Protect the sensitive information before AI reasoning begins.

Problem" width="800" height="450">

What Is MaskAgent?

MaskAgent is a privacy-first browser agent that combines browser
automation, DOM analysis, visual perception, sensitive-data detection,
local masking, and AI reasoning.

Its core principle is:

Perceive Locally → Protect Locally → Reason Intelligently

Instead of directly sending raw browser content to an AI model,
MaskAgent first analyzes the webpage locally.

Browser Screen
      ↓
DOM + Visual Perception
      ↓
Sensitive Data Detection
      ↓
Local Masking / Redaction
      ↓
Sanitized Context
      ↓
AI / LLM / VLM Reasoning
      ↓
Browser Action

Pipeline" width="800" height="450">

How MaskAgent Works

1. Perceive Locally

MaskAgent analyzes the browser environment using webpage structure and
visual information.

It can combine:

DOM information
Visual webpage information
UI elements
Text regions
Form fields
Page structure

2. Protect Locally

Sensitive information is detected and masked before it becomes part of
the AI reasoning context.

The goal is:

Raw sensitive data stays local.

3. Reason Intelligently

After sanitization, the AI receives a safer representation of the
webpage.

The agent can then reason about the task and determine the required
browser action.

4. Execute Locally

The browser agent can perform actions such as:

Click
Type
Scroll
Navigate

Actions" width="800" height="450">

The Privacy Boundary

The most important architectural idea in MaskAgent is the privacy
boundary.

┌───────────────────────────────────────────────┐
│             LOCAL / PROTECTED                 │
│                                               │
│ Browser → DOM + Vision → Detection → Masking │
│                                               │
└──────────────────────┬────────────────────────┘
                       │
                 Sanitized Context
                       │
                       ▼
┌───────────────────────────────────────────────┐
│                 AI REASONING                  │
│                                               │
│          LLM / VLM → Browser Action           │
│                                               │
└───────────────────────────────────────────────┘

The design principle is simple:

RAW SENSITIVE DATA STAYS LOCAL; ONLY SANITIZED CONTEXT REACHES AI.

Architecture" width="800" height="450">

DOM + Visual Perception

A major part of the planned MaskAgent architecture is combining
DOM-based understanding with visual perception.

DOM information can provide structured webpage information, while visual
perception can help understand what is actually displayed on the screen.

This combination can help MaskAgent detect sensitive regions more
precisely, especially on dynamic or visually complex webpages.

              WEBPAGE
                 │
        ┌────────┴────────┐
        ↓                 ↓
       DOM          Visual Perception
        │                 │
        └────────┬────────┘
                 ↓
       Sensitive Data Detection
                 ↓
          Mask / Redact

Why On-Device Processing?

Privacy-sensitive information should ideally be protected as early as
possible.

MaskAgent therefore focuses on local processing for sensitive-data
detection and masking.

Potential benefits include:

Reduced exposure of raw sensitive data
Better privacy control
Lower dependence on remote preprocessing
Faster local decisions for supported workloads
A clearer privacy boundary between perception and AI reasoning

The project also explores browser technologies such as WebGPU and
WebAssembly for lightweight local computation.

Technology Stack

Stack" width="800" height="450">

Area Technology

Browser Extension Chrome / Firefox
Extension Standard Manifest V3
Languages JavaScript / TypeScript
Browser APIs Chrome Extension APIs
Local Acceleration WebGPU / WebAssembly
ML Runtime ONNX Runtime Web / Transformers.js
AI Lightweight Vision Models / LLM / VLM
Local AI Interface Ollama
Backend / Services FastAPI
Privacy Layer DOM + Visual PII Detection, Masking and Redaction

Current Prototype

MaskAgent is being developed as a browser extension prototype.

The current project explores:

Browser-based AI interaction
DOM analysis
Sensitive-data detection
Privacy masking
Local AI integration
Browser automation
Click, Type, Scroll and Navigate actions

The project is being developed for Smart India Hackathon 2026, under
problem statement SIH26171 --- On-device Visual Perception for
Lightweight Browser Agents.

Example Privacy Flow

Imagine a webpage contains:

Name: Bhuvanesh M
Email: bhuvanesh@example.com
Account Number: 1234567890

Instead of directly giving the raw information to an AI reasoning
system, the privacy layer can transform sensitive fields into protected
representations.

For example:

Name: [PERSON]
Email: [EMAIL]
Account Number: [ACCOUNT_NUMBER]

The AI can reason about the structure and task while the original
sensitive values remain protected locally.

This is the core idea behind sanitized context.

Browser Automation

MaskAgent is designed around practical browser actions:

Click
  ↓
Type
  ↓
Scroll
  ↓
Navigate

The privacy layer sits before AI reasoning rather than being added after
the AI has already received the webpage.

Automation" width="800" height="450">

Activity and Agent Flow

A browser agent needs to continuously understand what is happening on
the page and decide what to do next.

MaskAgent separates perception, protection, reasoning and execution.

        ┌──────────────┐
        │    Browser   │
        └──────┬───────┘
               ↓
        ┌──────────────┐
        │  Perception  │
        └──────┬───────┘
               ↓
        ┌──────────────┐
        │   Privacy    │
        │   Protection │
        └──────┬───────┘
               ↓
        ┌──────────────┐
        │ AI Reasoning │
        └──────┬───────┘
               ↓
        ┌──────────────┐
        │   Browser    │
        │    Action    │
        └──────────────┘

Stream" width="800" height="450">

Where Can This Be Useful?

A privacy-first browser agent can be relevant to workflows where
webpages contain confidential information.

Potential application areas include:

Banking and Finance

Protect account details, transaction information and other financial
data during browser automation.

Healthcare

Reduce exposure of sensitive patient or medical information during
automated workflows.

Government

Support browser automation for portals that contain citizen or
administrative information.

Enterprise

Provide privacy-aware automation for internal dashboards, business
systems and confidential workflows.

Education

Support automated browser tasks while reducing unnecessary exposure of
student or institutional information.

Challenges

Building a privacy-first browser agent introduces several technical
challenges.

Inference Latency

Local visual or AI inference can be computationally expensive.

Approach: lightweight models and browser acceleration technologies.

Detection Errors

Sensitive information may be missed or incorrectly detected.

Approach: combine DOM information with visual perception and improve
detection rules/models.

Over-Redaction

Masking too much information can reduce the usefulness of the AI
context.

Approach: precise region detection and semantic placeholders.

Dynamic Webpages

Webpages can change continuously.

Approach: continuous page analysis and efficient browser-side
processing.

Limited Resources

Browser-based AI must work within available CPU, memory and GPU
resources.

Approach: lightweight inference, WebGPU acceleration and efficient
processing pipelines.

Privacy by Design

MaskAgent is built around a privacy-by-design concept:

        RAW PAGE
           │
           ▼
   ┌─────────────────┐
   │ Local Detection │
   └────────┬────────┘
            ↓
   ┌─────────────────┐
   │ Local Masking   │
   └────────┬────────┘
            ↓
     SANITIZED DATA
            │
            ▼
      AI REASONING

The objective is not simply to tell an AI model to "ignore" private
information.

The objective is to reduce exposure before AI reasoning receives the
context.

What Makes MaskAgent Different?

The project focuses on the combination of:

Browser automation
On-device visual perception
DOM understanding
Sensitive-data detection
Local privacy masking
Sanitized AI context
AI-based browser reasoning

The central design idea is:

Privacy should be part of the browser agent's perception pipeline,
not an afterthought.

Project Architecture

Architecture" width="800" height="450">

At a high level:

Browser
   │
   ├── DOM
   │
   └── Visual Screen
          │
          ▼
   Perception Layer
          │
          ▼
   Sensitive Data Detection
          │
          ▼
   Privacy / Masking Layer
          │
          ▼
   Sanitized Context
          │
          ▼
   AI Reasoning
          │
          ▼
   Browser Automation

Repository Structure

maskagent/
├── README.md
├── CONTRIBUTING.md
├── code_files/
│   ├── README.md
│   ├── background.js
│   ├── content.js
│   ├── manifest.json
│   ├── popup.html
│   ├── popup.js
│   ├── styles.css
│   └── icons/
├── img/
├── papers/
├── ppt_files/
├── index.html
├── developers.html
└── team.html

Try the Prototype

GitHub

https://github.com/bhuvanesh-m-dev/maskagent

Project Website

https://bhuvanesh-m-dev.github.io/maskagent

Demo

The demo explains the motivation behind MaskAgent and shows the working
prototype.

Research and References

The project explores technologies and documentation related to:

Chrome Extensions
Browser Extension APIs
WebGPU
WebAssembly
Ollama
Transformers.js
ONNX Runtime Web
FastAPI
Lightweight AI models
Browser automation
Privacy-preserving AI systems

Useful Documentation

Chrome Extensions: https://developer.chrome.com/docs/extensions
Chrome Extensions API: https://developer.chrome.com/docs/extensions/reference
WebGPU API: https://developer.mozilla.org/en-US/docs/Web/API/WebGPU_API
WebAssembly: https://webassembly.org/
Ollama: https://docs.ollama.com/
Transformers.js: https://huggingface.co/docs/transformers.js/en/index
FastAPI: https://fastapi.tiangolo.com/

Smart India Hackathon 2026

Project: MaskAgent --- Privacy-First Browser Agent

Problem Statement: SIH26171

Problem: On-device Visual Perception for Lightweight Browser Agents

Core Approach:

Perceive Locally → Protect Locally → Reason Intelligently

MaskAgent is being developed as a solution concept for privacy-aware
browser automation where sensitive screen information should be
protected before AI reasoning.

Roadmap

Future development areas include:

Improved visual PII detection
More precise bounding-box detection
DOM + vision fusion
Lightweight on-device models
Better dynamic webpage handling
Improved privacy masking
More browser actions
Improved local AI integration
Performance optimization using WebGPU
Broader browser compatibility

Limitations

MaskAgent is an active prototype and research-oriented project.

Detection accuracy, browser compatibility, inference speed and model
capabilities may vary depending on the webpage, device and selected AI
model.

The project should not be treated as a guarantee that all sensitive
information will always be detected or protected.

Team

Team DataSync

MaskAgent is being developed as part of the Smart India Hackathon 2026
project work.

Keywords

AI browser agent · privacy-first AI · browser automation ·
PII detection · on-device AI · local AI · Chrome extension ·
Manifest V3 · WebGPU · WebAssembly · visual perception ·
LLM browser agent · privacy-preserving AI · AI automation ·
sensitive data masking · DOM analysis

Final Thought

AI browser agents should not have to choose between intelligence and
privacy.

MaskAgent explores another approach:

Let the browser understand sensitive information locally, protect it
locally, and give the AI only the context it needs to reason.

Perceive Locally → Protect Locally → Reason Intelligently.

Connect With the Project

🌐 Website: https://bhuvanesh-m-dev.github.io/maskagent/\
💻 GitHub: https://github.com/bhuvanesh-m-dev/maskagent\
▶️ Demo: https://youtube.com/watch?v=_rl1w6US6_U

AI #BrowserAutomation #Privacy #ArtificialIntelligence #OnDeviceAI

WebGPU #ChromeExtensions #MachineLearning #LLM #CyberSecurity

🌱 Technology Meets Environmental Awareness

BHUVANESH M — Sun, 26 Jul 2026 06:36:25 +0000

Sometimes, the most meaningful software isn't built for businesses or clients.

It's built to create awareness.

During the third week of March 2026, I had the opportunity to participate in InnovAd Fest, the flagship technical event of BIOFEST'26, organized by the Department of Biomedical Engineering, Kings Engineering College.

Our objective was simple.

Use technology to communicate an environmental message in a way that people would actually engage with.

Instead of creating another PowerPoint presentation, our team decided to build an interactive digital experience.

That's how Anaya Green Day was born.

💡 The Idea

Environmental awareness campaigns are everywhere.

But most people forget them within minutes.

We wanted something different.

Something that people could open in a browser, interact with, and remember.

Rather than simply explaining why protecting nature matters, we wanted visitors to experience the message through a modern web application.

💻 My Contribution

I was responsible for designing and developing the interactive web platform that transformed our team's idea into a digital experience.

From planning the interface to implementing the website, my goal was simple:

Turn an environmental awareness campaign into something people could actually explore online.

The project focused on:

Clean UI/UX
Responsive Web Design
Interactive user experience
Easy accessibility
Fast loading performance
Public deployment for everyone

Instead of remaining an event-only presentation, the project became something anyone can visit at any time.

🌍 Explore the Project

Live Website

👉 https://bhuvanesh-m-dev.github.io/anaya-green-day/

Event Glimpse

🚀 Beyond Building a Website

This project reminded me that software development isn't only about writing code.

It's about solving problems.

Sometimes that problem is technical.

Sometimes it's social.

Sometimes it's environmental.

Technology becomes far more valuable when it helps people understand an important message.

🌿 A Small Feature I Loved Adding

One feature I particularly enjoyed integrating into this project was web search powered by CosmoTalker.

CosmoTalker includes an Ecosia-powered web search capability, allowing users to quickly search the web from within applications while supporting a search ecosystem focused on environmental initiatives. Ecosia also provides features such as search shortcuts, advanced search operators, AI-assisted search experiences in supported regions, and sustainability-focused search capabilities. :contentReference[oaicite:0]{index=0}

Instead of reinventing search, I wanted to make it easier for users to access information directly from the project while leveraging the capabilities available through Ecosia.

🔭 About CosmoTalker

If you haven't heard about CosmoTalker yet...

It's an open-source Python library I've been building that focuses on astronomy, space exploration, and developer-friendly utilities.

Some of its capabilities include:

🚀 SpaceX Information
🌌 NASA APOD
🛰️ CelesTrak Satellite Data
🔎 Ecosia-powered Web Search
📚 Offline Knowledge Database
⚡ Simple Python APIs

One of my goals with CosmoTalker is to build reusable tools that developers can integrate into their own projects instead of rewriting the same functionality repeatedly.

📸 Event Experience

Participating in InnovAd Fest wasn't just about presenting an idea.

It was about collaborating with teammates, learning from other innovators, and demonstrating how software can be used for something beyond traditional applications.

I'm grateful to my teammates, faculty mentors, organizers, and everyone who supported our project throughout the event.

💚 Final Thoughts

One lesson stayed with me throughout this project.

Technology is at its best when it creates positive impact—not just digital products.

Whether it's AI, web development, or open source...

I hope to continue building projects that solve problems, inspire curiosity, and make a difference.

Thank you for reading! ❤️

If you enjoyed this project, feel free to:

🌐 Explore the project:
https://bhuvanesh-m-dev.github.io/anaya-green-day

💻 Check out my other open-source work:
https://github.com/bhuvanesh-m-dev

🐍 Explore CosmoTalker:
https://pypi.org/project/cosmotalker

Follow me here on DEV for more open-source projects, AI experiments, Python libraries, and student developer experiences.

Happy Coding! 🚀

I had a feeling this would happen... 😄

BHUVANESH M — Mon, 20 Jul 2026 13:41:15 +0000

When Google integrated NotebookLM inside the Gemini app, I had one thought:

"NotebookLM's days as a standalone brand are numbered."

A few months later...

NotebookLM → Gemini Notebook.

At this point, Google's naming strategy feels like Pokémon evolution.

Google Now
      ↓
Google Assistant
      ↓
Bard
      ↓
Gemini
      ↓
Gemini Everywhere™ 😂

Think about it.

Back in the day, we had the legendary battle:

Google Assistant 🆚 Siri

"Hey Google..."

"Hey Siri..."

That was peak smartphone nostalgia.

Fast forward to today...

Google Assistant quietly steps aside.

Gemini becomes the default AI experience across Android, deeply integrated into the OS on many modern devices. On newer phones, it feels less like "an app" and more like part of Android itself. Sure, you can still change or disable the default assistant on supported devices—but Google's direction is pretty clear.

Meanwhile...

Apple looked at all the frontier AI models...

...and ended up partnering with Google.

So now, for some of Siri's advanced AI capabilities, there's Google's Gemini working behind the scenes.

Imagine telling someone this in 2023:

"One day Siri will answer using Google's AI."

They would've thought you were joking. 😂

Even funnier?

Apple's Neural Engine is running Apple's software...

while some of Siri's smartest cloud responses can come from Google's Gemini models.

The rivalry somehow became... teamwork. 🤝

Google's AI strategy now feels incredibly consistent:

✅ Bard → Gemini
✅ Google Assistant → Gemini
✅ NotebookLM → Gemini Notebook
✅ Android → Gemini-first experience

At this rate, don't be surprised if one day we see:

Gemini Photos 📸
Gemini Maps 🗺️
Gemini Calendar 📅
Gemini Calculator 🧮
Gemini Toaster™ 🍞

(Okay... maybe not the last one.)

And then there's ChromeOS...

With Google pushing AI deeper into Android, Workspace, Search, Chrome, and now NotebookLM, it's hard not to wonder if future operating systems will be designed around AI first, instead of adding AI later. Whether that's ChromeOS, Android, or something entirely new, Google seems to be building an ecosystem where AI isn't just another feature...

It's becoming the operating system's personality.

Maybe I was overthinking when NotebookLM landed inside Gemini...

Or maybe Google was quietly telling us the plan all along. 😄

Plot Twist 🤯

If you've reached this far...

There's one more funny thing.

The cover image of this very article was generated using Google's Gemini Nano model integrated into Dev.to. 😏

Wait...

OMG?

No...

Oh My God? ❌

Not anymore.

Oh My Google? 🤔

Close...

OH MY GEMINIIIIIIII!! 💎✨

At this point, Google's AI isn't just changing product names...

It's changing the punchlines too. 😂

🌍 Exploring DAO Communities as a Computer Science Engineering Student : My DEP2 Experience

BHUVANESH M — Fri, 29 May 2026 14:40:04 +0000

As a 2nd-year Computer Science Engineering student, I had the opportunity to participate in the onboarding and interview process for the Kambria DAO Experimentation Program (DEP2). Until then, most of my focus had been on software development, open-source projects, and building my own ideas. DEP2 introduced me to an entirely different perspective — decentralized collaboration, DAO governance, community-driven innovation, and global knowledge-sharing networks.

Through the application process, community discussions, and interactions with participants from different backgrounds, I learned how DAOs operate, how contributors coordinate across countries, and how technology can be used to create collaborative ecosystems without traditional organizational structures. It was fascinating to see people working together around shared goals, exchanging knowledge, and experimenting with new models of innovation.

Although I was not selected for the final cohort, I genuinely consider the experience a valuable milestone in my learning journey. Sometimes opportunities do not end with a selection letter — they leave behind something even more important: knowledge, perspective, and motivation to keep growing.

Now, as a pre-final year Computer Science Engineering student, I look back on this experience with gratitude. It broadened my understanding of global tech communities, strengthened my interest in open collaboration, and encouraged me to explore ideas beyond conventional software development.

A sincere thank you to the Kambria team for the opportunity, the conversations, and the learning experience throughout the process. Every interaction added value, and every experience contributes to the journey.

🚀 Keep learning. Keep building. Keep exploring.

From a Python Library to a Universal API — My CosmoTalker Journey as a CSE Student

BHUVANESH M — Sun, 24 May 2026 08:42:38 +0000

When I entered my 1st year of Computer Science Engineering 2nd phase, I never expected one small idea would grow into one of my biggest projects.

That idea became CosmoTalker.

It started as a simple Python library built out of curiosity, experimentation, and my interest in astronomy and developer tools. During my first year, I focused on learning how APIs, JSON responses, libraries, and backend systems work while continuously adding new features to the project.

As time went on, CosmoTalker slowly evolved beyond just a small Python package.

🚀 2nd Year — Building the Core System

During my 2nd year, I started developing the major parts of CosmoTalker seriously.

I improved:

backend structure
feature support
API logic
astronomy data handling
developer usability
multi-platform accessibility

This phase became one of the most important milestones in my development journey.

One of the proudest moments was when the project received recognition through TASS at YASSC’25 as a best project work achievement. That recognition motivated me to push the project even further.

🌍 3rd Year (Pre-Final Year) — The Universal API Era

Now, as I enter my pre-final year in CSE, CosmoTalker has transformed into a universal API platform.

Instead of being limited to Python, the API now works with almost every programming language including:

Python
JavaScript
TypeScript
Go
Rust
Java
C#
PHP
Kotlin
Swift
C++
and many more...

The vision became much bigger:

“If a language can make an HTTP request, it should be able to use CosmoTalker.”

Today, I’m actively developing:

new API features
improved response systems
better developer experience
AI integrations
space data tools
offline ecosystem support
cross-language compatibility

CosmoTalker is no longer just a student experiment — it has become a growing developer ecosystem.

💡 What Makes CosmoTalker Different?

CosmoTalker focuses on:

simplicity
universal access
lightweight integration
developer-friendly APIs
multi-language support
space & astronomy data

The goal is to make space technology accessible to developers everywhere without requiring complicated SDKs or heavy installations.

🎥 Watch the Project Demo

🔗 Project Links

🌌 GitHub Repository: https://github.com/bhuvanesh-m-dev/cosmotalker
🚀 Developer Portal: https://bhuvanesh-m-dev.github.io/cosmotalker/api/get/developers.html
👨‍🚀 AI PlayGround Portal : https://bhuvanesh-m-dev.github.io/cosmotalker/api/get/llm-playground.html
🌍 API Endpoint: https://cosmotalker.onrender.com/api/get?q=

🔮 Towards Final Year…

Sometimes I look back and think:

“This started as a first-year learning project.”

Now entering my final academic phases as a CSE student, I’m excited to see what CosmoTalker could become by final year.

Maybe:

a complete open-source ecosystem
an AI-powered astronomy platform
a developer toolkit used globally
or something even bigger

The journey is still continuing.

And honestly…

I think the best parts of CosmoTalker are still ahead. 🌌

Gemini’s New UI + 3.5 Flash: Google Is Building an AI-Native Developer Experience

BHUVANESH M — Wed, 20 May 2026 02:35:53 +0000

Google just gave Gemini a major glow-up at Google I/O 2026, and this feels less like a chatbot refresh and more like the beginning of an AI-native operating experience for developers.

The new Gemini UI looks cleaner, faster, and far more focused on workflow. The redesigned “Ask Gemini” interface, smoother animations, contextual tools, and simplified model selector make the experience feel lightweight while still being powerful.

Google is clearly moving toward an AI-first UX where the assistant becomes part of the workflow instead of just a separate chat window.

What Stands Out in the New UI

Minimal and distraction-free design
Faster access to models and tools
Better workflow-oriented layout
Cleaner interaction experience
More integrated AI workspace feel

The overall interface now feels closer to a productivity environment rather than a traditional AI chat app.

Gemini 3.5 Flash Looks Interesting for Developers

What caught my attention most is Gemini 3.5 Flash.

Google is positioning 3.5 Flash as a high-speed model optimized for:

Coding workflows
Agentic tasks
UI generation
Iterative development
Long-context execution
Fast response generation

The speed improvements genuinely look impressive.

This is where things start becoming exciting for developers.

We’re entering an era where:

AI assists during the actual build process
Prototyping becomes conversational
Frontend generation becomes iterative in real time
Agents can execute multi-step workflows instead of only answering prompts

Why This Matters

Gemini’s redesign reflects a larger shift happening across the AI ecosystem.

AI tools are no longer just assistants.
They’re becoming development environments.

The new UI reflects that direction:

Minimal distractions
Contextual actions
Faster workflow switching
Better tool accessibility
Workspace-style interactions

Google still has strong competition from OpenAI, Anthropic, and the open-source ecosystem, but Gemini 3.5 Flash feels like Google finally aligning:

Infrastructure
Multimodal AI
Developer tooling
UI/UX polish
Workflow integration

into one ecosystem.

Final Thoughts

The next phase of software development may not just be about writing code faster.

It may be about:

Designing, testing, debugging, generating, and deploying — all through AI-native workflows.

And Gemini’s new UI combined with 3.5 Flash feels like a strong step in that direction.

Gemini app new UI

BHUVANESH M — Wed, 20 May 2026 02:05:50 +0000

Building Space Apps in the Browser with GalacticCode and CosmoTalker

BHUVANESH M — Thu, 23 Apr 2026 07:29:52 +0000

Most online Python compilers allow basic execution, but they usually do not support installing or using third-party libraries like numpy, pandas, or custom modules.

This limits what users can actually build.

To address this, I created a browser-based Python environment where code runs instantly and libraries can be used without manual installation.

GalacticCode runs Python directly in the browser using WebAssembly (Pyodide). It executes code locally, so there is no backend dependency, no file upload, and no setup required.

CosmoTalker is integrated into this environment, allowing users to access space-related data and build small applications directly.

With this setup:

Python runs instantly in the browser
CosmoTalker is preloaded
No installation or configuration is required
Code executes locally

Example:

import cosmotalker

print(cosmotalker.get("mars"))
cosmotalker.apod()

You can run the above example directly here:
https://bhuvanesh-m-dev.github.io/galacticcode/?code=aW1wb3J0IGNvc21vdGFsa2VyIApwcmludChjb3Ntb3RhbGtlci5nZXQoIm1hcnMiKSkgCmNvc21vdGFsa2VyLmFwb2QoKQ==

Another example (multiple planet data):
https://bhuvanesh-m-dev.github.io/galacticcode/?code=aW1wb3J0IGNvc21vdGFsa2VyCnByaW50KGNvc21vdGFsa2VyLmdldCgidmVudXMiKSkKcHJpbnQoY29zbW90YWxrZXIuZ2V0KCJtYXJzIikp

The Astronomy Picture of the Day (APOD) fetched today:

Demo video:

The objective is to reduce setup friction while still allowing practical experimentation and small-scale application development directly in the browser.

https://bhuvanesh-m-dev.github.io/galacticcode

🚀 A Wake-Up Call for Developers: Don’t Just Build — Publish Your Ideas to the Linux Ecosystem

BHUVANESH M — Wed, 31 Dec 2025 11:57:29 +0000

Every day, developers create scripts, tools, and utilities that solve real problems. Many of them make Linux friendlier, automate workflows, or simplify everyday tasks.

But most of these ideas never leave a local folder.

They stay inside our machines — instead of becoming part of the Linux ecosystem.

And that’s the wake-up call I want to share today.

🧠 Linux Grows Only When Developers Share

Linux became powerful because developers shared what they built — not because everything was perfect, but because it was useful.

That spirit is what inspired projects like Setbian — Make Linux Meaningful.

💡 If your project solves even one real problem — it deserves to exist in the ecosystem.

The ecosystem grows only when developers publish, collaborate, and contribute.

🌍 From “Personal Script” → To “Linux Contribution”

When you publish your tool or idea, you’re doing more than uploading code — you’re helping someone else who needed exactly that solution.

Setbian’s App Portal is an example of this collaborative mindset.

It exists to help developers share their apps — not just build them privately.

Even a small bash script or Python utility can become:

a shared .deb package
a community tool
part of someone else’s workflow

That is the power of publishing.

🤝 Don’t Just Build — Publish Your App

Setbian encourages developers to bring their ideas into the open through the Publish Your App workflow.

Here, creators can:

Submit apps
Share their work
Become part of a growing Linux ecosystem

Because projects evolve only when they are visible —

through feedback, contributions, and collaboration.

🎥 Watch: Setbian

Here’s a short video about the vision behind publishing and community-driven development:

🚀 If You Built Something… Share It.

Whether it’s:

a GUI tool
a terminal utility
a Debian helper script
a small learning project

Don’t let it remain hidden.

Publish it. Share it. Let it breathe.

Let it become part of the Linux journey.

🌱 Someone out there is waiting for exactly what you created.

🌱 The Ecosystem Grows When We Do

This is a call to fellow developers, students, and creators:

✊ Stop hiding your ideas.

Share them with the world.

Linux becomes stronger when you contribute.

If you’ve built something — big or small — drop your project link in the comments.

Let’s encourage more developers to publish, collaborate, and shape the future of the Linux ecosystem together.

Google's Aluminium OS

BHUVANESH M — Sun, 28 Dec 2025 04:22:34 +0000

In the evolving landscape fo personal computing, Google has embarked on a transformative journey to unify its ecosystems. Aluminium OS, the internal codename for an Android-based desktop operating system, represents the culmination of efforts to merge Android's vast app ecosystem and mobile prowess with ChromeOS's secure, web-centric foundation.

Built with artificial intelligence at its core—featuring deep integration of Gemini models—this platform promises seamless experiences across devices, from smartphones to premium laptops, tablets, detachables, and mini-PCs. As of late 2025, internal testing on Android 16 builds progresses steadily, with hardware partners preparing for broader adoption.

The transition strategy ensures continuity: existing ChromeOS devices will receive updates through their supported lifecycles, potentially allowing migrations where hardware permits, while new Aluminium-powered devices target entry-level to premium segments. Anticipated launches in 2026 mark Google's ambitious challenge to established desktop leaders, fostering a unified, AI-enhanced environment that empowers developers with cross-device compatibility and users with intuitive, intelligent computing.

This development signals a profound shift toward an interconnected digital future.

Follow me on:

🐦 X (Twitter)

💼 LinkedIn

💻 GitHub

🚀 Oolit: Featured Internationally + Now Evolving into a ML Model

BHUVANESH M — Sat, 06 Dec 2025 13:38:05 +0000

Over the past few months, I’ve been working on Oolit, an offline AI feature built for the CosmoTalker ecosystem. What started as a simple function to deliver space-related answers without internet connectivity has now reached an exciting milestone.

🌍 1. Oolit Featured Internationally

Oolit was recently highlighted in a technical article by KiteMetric, a Vietnam-based software development company:

🔗 Article: https://kitemetric.com/blogs/introducing-oolit-your-offline-ai-chatbot-for-cosmotalker

This recognition comes shortly after my other open-source project, ZentoraOS, was featured by teams in Spain and India.
It's motivating to see projects built at a small scale find visibility across different countries.

🤖 2. Oolit Is Now Evolving into a Machine Learning Model

Oolit has grown beyond a standard function — it’s now being developed into its own Machine Learning model, with a long-term goal of becoming a lightweight, open-source LLM.

🔗 Repo: https://github.com/bhuvanesh-m-dev/oolit

The idea is to keep Oolit fast, offline, and developer-friendly, while steadily improving its intelligence through incremental model updates.

I’m excited to continue building and exploring what’s possible with open-source AI, minimal models, and offline-first tools.

More updates coming soon! 🚀

ZentoraOS Receives Global Recognition from Q2B Studio 🇪🇸

BHUVANESH M — Wed, 05 Nov 2025 12:41:59 +0000

I’m excited to share that ZentoraOS, my open-source Linux project built with offline AI capabilities, was recently featured by Q2B Studio, a software development company based in Spain.

Their detailed article — “Presentando ZentoraOS” — explores how the OS blends the familiarity of Windows with the power of Linux and built-in AI tools powered by Ollama.

Seeing a project I started as a student in India reach an international audience is truly rewarding.

It’s a reminder that in open source, code speaks beyond borders. 🌍

🔗 Read the article by Q2B Studio

🔗 Learn more about ZentoraOS