DEV Community: BHUVANESH M

🌍 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

🧠 When All LLMs Write the Same C Code: A Curious Case of “Alice, Bob, Charlie, Diana”

BHUVANESH M — Tue, 04 Nov 2025 07:30:59 +0000

Date: November 4,2025

💡 Introduction

Recently, while testing multiple AI coding assistants — ChatGPT, Copilot, Claude, Gemini, Grok, DeepSeek, Kimi, Meta, Qwen, and Perplexity — I noticed something curious.

Whenever I asked each model to “Write a Stack program in C with push and pop operations”, they all generated almost identical outputs — including the same names in the example code:

push(&s, "Alice");
push(&s, "Bob");
push(&s, "Charlie");
push(&s, "Diana");

Different models. Different companies. Same names.
So what’s going on here?

🧩 The Setup

I ran the same base prompt across 10 LLM-based coding tools:

“write a c prgm to push and pop, stack prgm with example of names”

Each model produced syntactically correct code, with minor stylistic differences — but nearly all used the same sequence of names: Alice, Bob, Charlie, Diana.

Some even printed the same formatted output structure:

Current stack (top to bottom):
Diana
Charlie
Bob
Alice

You can check the screenshots and chat logs here:
🔗 https://chatgpt.com/share/6909995f-2ef4-800b-a811-373f144d8cde
🔗 https://copilot.microsoft.com/shares/H5n3ZdH455JZsejbt8xTX
🔗 https://chat.qwen.ai/s/c5435fa7-4e7f-4111-8405-9f1b8a3a7264?fev=0.0.237
🔗 https://grok.com/share/c2hhcmQtMw%3D%3D_090f0c4b-6b16-4c80-aca5-d216d12fc118
🔗 https://chat.deepseek.com/share/kzmuks1r5jyr9lu4a4
🔗 https://gemini.google.com/share/760142d445e0
🔗 https://www.kimi.com/share/d44q1eiav1fdpe56ml90
🔗 https://www.meta.ai/share/bd3NRucWiAt/
🔗 https://claude.ai/share/691c0dd9-74f5-465c-b5bd-b6db775d97b1
🔗 https://www.perplexity.ai/search/write-a-c-prgm-to-push-and-pop-oG.NzePvRbugHB6FtP.J8w#1

🧠 Why This Happens

This isn’t coincidence — it’s convergence.
Here’s why it happens across models:

Shared Training Data
Most open and commercial LLMs are trained on overlapping public datasets — including open-source code, Stack Overflow posts, and textbook-style programming examples.
Many of those sources reuse familiar placeholder names (Alice, Bob, Charlie, Diana, Eve), especially for networking or data structure examples.
Prompt Safety & Predictability
When asked for code without context, models bias toward canonical, safe, and commonly seen examples — minimizing the risk of generating unpredictable or offensive outputs.
Reinforced Learning Patterns
These names form a semantic cluster the models recognize as “typical names used in examples.”
Thus, across different LLMs, you get parallel recall of the same patterns.

🧩 What It Tells Us About LLM Behavior

This small observation reveals some big truths:

🤖 LLMs don’t “copy” each other — they converge because they learn from overlapping human data.
🧱 Training data shapes creativity — when training data is generic, outputs tend to look generic too.
🔭 Prompt design matters — adding context (“use sci-fi character names” or “simulate a warehouse stack system”) yields much more diverse results.

🔍 Implications for Developers and Researchers

For developers: Don’t be surprised by repetition. If you need originality, steer the model with unique context or seed data.
For educators: LLM outputs reflect common teaching examples. This can reinforce learning consistency — but may hide creativity potential.
For AI researchers: This is a neat case of emergent alignment — showing how independent models can produce near-identical examples due to shared priors.

💬 Closing Thoughts

When ten different AI models write the same C program — complete with Alice, Bob, Charlie, and Diana — it’s not laziness; it’s learning convergence in action.

What started as a trivial stack example turned into a fascinating glimpse of how AI models internalize patterns from the same educational DNA.

Sometimes, the code says more about the data behind the model than the model itself.

#AI #LLM #MachineLearning #Programming #C #OpenAI #Qwen #Claude #Gemini #GitHubCopilot #AIObservations

🎉 Fun Fact

Meta AI gives different data! It outperforms here by generating more diverse examples and outputs, breaking away from the “Alice, Bob, Charlie, Diana” pattern. This could indicate differences in training datasets, sampling strategy, or reinforcement techniques used by Meta’s model.

📎 Bonus

If you want to replicate this experiment:

Ask multiple AI tools to with same prompts.
Compare variable outputs.
Watch the convergence unfold. 🧩
Leave your comments below!👇

PyLlamaUI Update

BHUVANESH M — Sat, 18 Oct 2025 07:48:30 +0000

Markdown Output

Offline Agentic Mode Coming Soon

I'm thrilled to share that PyLlamaUI now supports structured Markdown output — fully offline.

This lets you view beautifully formatted text, code blocks, tables, and responses directly in your local app with no cloud dependency. ⚡

🧠 Watch It in Action

Here’s the video proof of Markdown output working offline 👇

🔜 What’s Next — Agentic Mode

The next major update of PyLlamaUI and PyLlamaUI-CLI will introduce:

🤖 Agentic Mode – Local reasoning agents that can handle tasks autonomously
🧩 Task chaining – Enable agents to connect steps intelligently
🔒 Fully offline operation – No external APIs, no tracking, just pure local AI

💡 About PyLlamaUI

PyLlamaUI is an open-source offline AI interface built in Python, designed to interact with local Ollama models.

It’s simple, lightweight, and privacy-friendly — perfect for developers who prefer full control over their LLM environment.

🖥️ Visit Project Page → bhuvaneshm.in/pyllamaui

💻 View on GitHub → github.com/bhuvanesh-m-dev/pyllamaui

👨‍💻 Developed by

Bhuvanesh M

🌐 bhuvaneshm.in

🐙 GitHub 💼 LinkedIn 🐦 Twitter

“No cloud. No limits. Just pure local intelligence.”

Gemini3

BHUVANESH M — Sun, 12 Oct 2025 14:51:31 +0000

The AI world is buzzing with anticipation for Google's unreleased Gemini 3, which, despite a rumored October 9 launch not materializing, is expected to be a monumental leap in AI. Leaks suggest frontier-level performance, with unparalleled coding speed and advanced multimodal capabilities. Influencers and the tech community are on high alert, eagerly awaiting what could be the next state-of-the-art model.

For developers, the hype centers on the promise of revolutionary tools that could generate full apps and debug code agentically. This release is seen as Google's direct challenge to competitors, with immense pressure to deliver a game-changing product. The outcome of this wait will likely spark the next major wave of AI-powered innovation and creativity.