ClonMed

a new way to educate

Comment

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.

Built With

Share this project:

Updates