ClonBrow

timetable maker
words proccessor and writer
receipt maker and editor
game hub
browser landing page search engine
dashboard
labs
landing page
Cli interface
workflow

Inspiration

Modern enterprise infrastructure and educational systems are dangerously dependent on continuous cloud connectivity. In air-gapped environments, low-connectivity regions, or during server outages, productivity and training completely halt. We realized that web applications are powerful, but relying on browsers and remote servers introduces massive friction and security vulnerabilities for internal operations. ClonBrow v2 (Project Clonverse) was inspired by a rebellion against this cloud dependency—a drive to bring complex, high-fidelity web applications down to the bare-metal, offline-first level.

What it does

ClonBrow v2 is a highly secure, terminal-driven operating ecosystem designed specifically for offline execution. It acts as an internal command center that unifies over 211+ pre-compiled modules—ranging from STEM physics engines and the ClonMed diagnostic AI to secure enterprise network simulations. Using an intent-based Python logic router, users input natural language commands into a "Red Hacker" aesthetic terminal, and the system instantly deploys the corresponding "Liquid Glass" UI module locally, bypassing the need for web searches, cloud processing, or standard browsers.

How we built it

We engineered a Dual-Layer Architecture to completely separate computational logic from visual rendering:

The Kernel Layer (Backend): Built with Python 3.10+ and the Rich library. This handles all local file decryption, root authentication (admin), and the intent-based AI parsing.
The Execution Layer (Frontend): A massive localized library consisting of HTML5 (93.5% of the codebase), Vanilla JavaScript (ES6+), and Tailwind CSS.
The Bridge: We utilized local Python Subprocess Inter-Process Communication (IPC) to route data between the terminal backend and the GUI modules.
The Packaging: We wrapped the entire ecosystem using Electron and Nativefier, compiling the fragmented web-stack into a single, standalone native .exe.

Challenges we ran into

The GitHub Boss Fight: When compiling the project into a standalone OS environment, the resulting .exe ballooned to 155.69 MB, instantly hitting GitHub's hard 100MB file limit and rejecting our deployment. We had to rewrite our Git history, implement advanced .gitignore parameters, clear the remote cache, and isolate the source code to push a clean 35.53 MB architecture successfully.
Subprocess Memory Management: Routing data seamlessly between a CLI terminal and a graphical web-stack without spinning up a heavy local web server was difficult. We had to carefully manage the Python Subprocesses to ensure the system didn't suffer from thermal overload or memory leaks when launching heavy frontend modules on low-end hardware.

Accomplishments that we're proud of

Successfully decoupling the UI from the backend kernel, allowing complex graphical applications to run smoothly on legacy internal hardware.
Manually curating, integrating, and routing 211+ distinct offline modules into one cohesive, instantly accessible library.
Engineering the Enterprise Verification module (> ibm x unsa), which flawlessly simulates secure mainframe handshakes and data routing protocols entirely offline with zero latency.

What we learned

Web technologies (HTML/JS/CSS) can be transformed into incredibly powerful desktop and internal tools when stripped of the traditional browser environment.
Advanced version control and repository management. Hitting critical server-side errors forced a deep dive into Git cache manipulation and force-pushing (git push -f).
How to build effective Inter-Process Communication (IPC) pipelines, proving that Python command-line interfaces can safely pilot heavy graphical frontends.

How does it save time, cut costs, or generate value?

Saves Time: Zero latency. Because all 211+ modules are pre-compiled and run locally on the bare metal, tools and simulations load instantly from local memory instead of waiting for API responses or server requests.
Cuts Costs: It drastically reduces the need for continuous cloud server uptime, expensive enterprise API subscriptions, and heavy local bandwidth consumption.
Generates Value: It enables seamless employee onboarding, infrastructure training (like the IBM Z mainframe interactions), and operational diagnostics in totally air-gapped, highly secure, or remote environments where internet access is either restricted or completely unavailable.

What's next for ClonBrow v2

Local LLM Integration: Upgrading our natural language parser to run a lightweight, locally hosted Large Language Model (e.g., Llama 3 8B) to provide dynamic, pure-offline conversational routing.
P2P LAN Syncing: Developing a mesh-network protocol so multiple Clonverse terminals in the same disconnected room or corporate office can share data locally without wide-area internet.
Expanded Enterprise Sandboxes: Partnering with infrastructure architects to build out full, offline network topology sandboxes for risk-free internal cybersecurity training.

Functional Prototype and Track Alignment

The core of the submission is a fully functional prototype that directly targets one of the official hackathon tracks or the open innovation category. This is not a conceptual wireframe or a theoretical slide deck; it must be a working build that executes its core premise. The architecture should clearly reflect the chosen track's objectives, proving that the concept can survive the transition from an idea to deployed software.

Clear Problem Identification

Before writing a single line of code, the system must justify its own existence by targeting a real, high-friction problem. A strong project isolates a specific pain point—such as broken cloud dependency, inefficient corporate workflows, or inaccessible resources for rural areas—and defines exactly who suffers from it. The architecture should be a direct, logical answer to this clearly defined bottleneck, leaving no ambiguity about why the tool was built.

Innovative Approach or Solution

The solution must break away from generic templates and basic chatbot wrappers. It requires a fresh, unconventional angle to the established problem, whether that means using bare-metal offline execution, novel data routing, or a completely new operational paradigm. The architecture should challenge the standard industry approach and offer a method that is noticeably faster, smarter, or more resilient than the existing status quo.

Technical Implementation

This is where the actual engineering is judged. The project must demonstrate robust backend logic, clean data pipelines, and a stable execution layer. Whether it utilizes inter-process communication, complex database schemas, or a decoupled frontend-backend architecture, the code must execute flawlessly. A strong implementation proves that the developer understands system stability, local memory management, and the mechanics of building a production-ready environment.

Usability and User Experience

A powerful backend is useless if the frontend is a nightmare to navigate. The prototype must feature an intuitive interface that guides the user naturally through the core workflow without requiring a manual. This means fast response times, clear visual hierarchies, and immediate feedback for user actions. Whether utilizing a clean corporate dashboard or a terminal-driven aesthetic, the design language must remain consistent, proving that the developer respects the end-user's cognitive load.

Scalability and Feasibility

The system must be built with the future in mind, proving it can handle growth without catastrophic failure. The underlying architecture should demonstrate that it can support an increasing number of users, larger datasets, or the addition of hundreds of new modules without requiring a complete rewrite. Furthermore, the project must be economically and technically viable in the real world, showing a clear, realistic path from a weekend prototype to a fully deployed, sustainable infrastructure.

Slides deck

Slides deck-https://drive.google.com/drive/folders/1ANZCaXU27uioRSFefAvZtRl0sbJeT4pB?usp=sharing

For whom By whom

This ambitious project is for those who are living in rural India, or this project is opted for the ones who cannot afford pricey and costly labs and courses; our labs are accessible. This was specifically made for accessibility. This was a vision made for this project. This project has 200+ labs, 10+ games and various other student tools and a search engine.

A note from the founder

I started this project because I know exactly what it feels like to have a passion for science and tech, but no place to experiment. As a 13-year-old student, I’ve felt the disappointment of realizing that a real, fully-equipped lab is either too costly or too far away to access regularly. Education shouldn't be limited by geography or budget. That’s why I decided to build a solution that puts the entire lab experience right at your fingertips. Right now, we’ve successfully mapped out and built over 181 interactive modules for you to use. But this is only version one. As we move forward into the next few months and years, this library of modules is going to continuously grow and evolve, making hands-on learning accessible to everyone.

⚖️ Proprietary Rights & Software License Notice

Software Product: Project Clonverse (ClonBrow-v2)

Lead Developer and Architect: Shree Kale

Effective Date: May 2026

1. Intellectual Property The software known as Clonverse OS, including the core system bootloader, intent-based AI routing logic, UI architecture, and the comprehensive library of 211+ localized modules, is the exclusive intellectual property of the developer. All rights remain strictly with the original developer.

2. Permitted Evaluation Individuals, including hackathon judges and technical evaluators, are granted permission to download, install, and execute the software solely for the purposes of technical evaluation and local academic review.

3. Strict Prohibition Unauthorized use beyond the permitted evaluation scope is strictly prohibited, including copying, mirroring, reverse-engineering, or distributing the source code or proprietary logic without prior written consent.

4. Commercial Licensing The reproduction or reuse of this software for any commercial purpose is strictly forbidden. To discuss professional deployment, you must obtain official permission directly from the developer.

🏆 System Acknowledgments & Credits

Project Leadership

This project represents a massive independent engineering effort built entirely from the ground up.

Lead System Architect & Founder: Shree Kale
Full-Stack Development & Interface Design: Shree Kale
Contact: nikitakale1974@gmail.com

Dependencies and frameworks used

The Clonverse OS architecture relies on a blend of custom logic and established frameworks to execute its dual-layer environment efficiently.

Repository Language Breakdown:

HTML: 93.5%
JavaScript: 5.1%
Python: 1.1%
C#: 0.2%
TypeScript: 0.1%
Batchfile: 0.0%

Core Frameworks & Libraries:

Frontend Engine: HTML5, Vanilla JavaScript (ES6+), and Tailwind CSS for the 211+ localized modules and Liquid Glass UI.
Backend Engine: Python 3.10+ handling core intent logic and file decryption.
Terminal Interface: The Rich Python library for high-definition CLI rendering and live diagnostic panels.
Packaging Infrastructure: Electron and Nativefier to compile the web-stack and Python processes into a standalone executable.
Deployment Network: Netlify for the high-speed cloud uplinks and landing page hosting.