DEV Community: Shriraj Patil

EatWise AI: An Open-Source AI Nutrition Companion for Smarter, Healthier Eating

Shriraj Patil — Tue, 13 Oct 2026 21:47:02 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

EatWise AI — Your Personal AI-Powered Nutrition Companion 🥗🤖

EatWise AI is an AI-powered nutrition and wellness tracker that helps people make smarter, data-driven decisions about their daily food habits.

Many people want to eat healthier but struggle to track calories, understand macronutrients, plan meals, or determine whether their daily eating habits align with their wellness goals. EatWise AI brings these tasks together in one platform.

What can you do with EatWise AI?

Personalized Nutrition Goals: Calculate daily calorie and macronutrient targets based on your profile, activity level, and health goals.
AI Meal Analyzer: Upload a food image or describe a meal to receive estimated calories, macronutrients, a health score, and suggestions.
Smart Meal Tracking: Log, edit, and manage meals while monitoring daily nutrition progress.
AI Recipe Generator: Discover recipe ideas using ingredients you already have, with dietary filters and estimated nutritional information.
Health & Wellness Dashboard: Track hydration, mood, sleep, BMI, and overall wellness indicators.
Daily AI Insights: Get personalized, AI-generated nutrition insights to help build healthier habits.
Food Search: Retrieve food and nutritional information using the Open Food Facts API.

The goal is to make nutrition tracking more accessible, understandable, and practical for everyday users.

Who is it for? Students, fitness enthusiasts, busy professionals, and anyone who wants to develop healthier eating habits. It could also serve as a foundation for nutrition-focused wellness products and services.

The project supports UN Sustainable Development Goal 3: Good Health and Well-Being.

Demo

🚀 Try EatWise AI: https://eat-wise-ai-rho.vercel.app

Explore the application and try its nutrition tracking, meal analysis, recipe suggestions, and wellness features.

Code

💻 GitHub Repository: Shriraj888/EatWise-AI

The project is open source under the MIT License.

Feel free to explore the code, report issues, suggest improvements, or contribute new features.

How I Built It

I built EatWise AI as a React-based web application with a modular architecture for the interface, state management, nutritional calculations, and AI integrations.

Technology Stack

Frontend: React 19, Vite 8, React Router
State Management: Zustand with persistence middleware
Data Visualization: Recharts
UI & Animation: Lucide React, Framer Motion, GSAP
AI Providers: Google Gemini and OpenRouter
Food Data: Open Food Facts API
Deployment: Vercel

How the AI works

The application integrates AI into practical nutrition workflows rather than using it only as a chatbot.

Meal analysis: Users provide a meal image or text description. The AI estimates calories and macronutrients and generates health-related observations.
Recipe generation: Users enter available ingredients and dietary preferences to receive recipe ideas, preparation steps, and estimated nutrition information.
Personalized insights: The AI generates daily nutrition insights using the application's nutrition and wellness context.

The application supports both Google Gemini and OpenRouter. Its AI provider service tries Gemini first when configured and can fall back to OpenRouter if Gemini fails and an OpenRouter key is available.

For nutrition goals, the application uses the Mifflin–St Jeor equation to estimate basal metabolic rate and calculates daily energy targets based on activity level and user goals. These calculations complement, rather than replace, the AI-generated insights.

Why this architecture?

I wanted the application to be modular and practical to extend. AI integrations, food search, reusable components, nutritional calculations, and global application state are separated into dedicated parts of the codebase.

The current implementation stores application state in the browser using Zustand persistence. It does not currently provide full authentication, user accounts, or server-side cloud synchronization.

AI-generated nutritional values are estimates and are not medical advice.

Why Does Open Innovation Matter?

Nutrition and wellness tools should not have to be limited to expensive, proprietary platforms.

Open innovation makes it possible for developers to experiment with different AI providers, inspect implementations, learn from existing projects, and adapt tools to their own communities.

For EatWise AI, an open-source frontend combined with support for multiple AI providers makes experimentation more flexible. Gemini and OpenRouter provide alternative ways to power AI features, while Open Food Facts supplies a public source of food product information.

Open innovation also allows other developers to improve the project by contributing better nutritional calculations, additional food data integrations, improved prompts, accessibility enhancements, and more robust AI output validation.

A closed API would not automatically prevent these possibilities, but an open codebase lets contributors inspect and modify the application's implementation rather than depending entirely on a vendor-controlled product.

My vision is to keep building EatWise AI as an approachable, extensible starting point for AI-powered nutrition and wellness applications.

My Agent Session

I don't have a shareable DevRelay agent session to include in this submission yet.

The source code and implementation are available in the EatWise AI GitHub repository.

Prize Categories

Challenge: Hacktoberfest Open-Source AI Challenge — Week 2: Side Hustle.

Additional partner prize categories are not listed here because I haven't verified which ones the project qualifies for. Update this section with the applicable categories from the challenge page before publishing.

Built to make healthier food decisions easier through AI and open source.

Submission: Hacktoberfest Open-Source AI Challenge Week 1 (Touch Grass)

Shriraj Patil — Wed, 07 Oct 2026 15:56:36 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

Cross Context is an open-source browser extension that lets you migrate an entire AI conversation — code, errors, architectural decisions, everything — from one LLM to another in a single click. Claude → ChatGPT → Gemini → Grok → Perplexity, any direction.

No cloud servers. No accounts. No data leaves your browser.

Why "Touch Grass"?

Every developer knows the drill: you're deep in a debugging session with Claude, you hit a rate limit, and suddenly you're spending 30 minutes manually copy-pasting code snippets into ChatGPT, re-explaining your architecture, and fixing Markdown formatting that broke during transfer. That's 30 minutes of screen time that shouldn't exist.

Cross Context kills that friction. Scrape → pick a target → transfer. Five seconds. Then close your laptop and go outside.

The screen should be the shortest part of the experience. That's the whole point.

Who is it for?

Developers who pair-program with AI and refuse to restart from scratch when they hit a wall
Researchers who compare model responses using identical ground-truth context
Privacy-first builders who won't send conversation history through third-party sync clouds

Demo

🔗 Live Prototype: cross-context.vercel.app

The 3-step handoff:

Scrape — Open any active chat on a supported platform. Click Cross Context → Scrape Context (or AI Handoff for Gemini-enhanced distillation).
Target — Pick your destination: ChatGPT, Claude, Gemini, Grok, or Perplexity.
Transfer — Cross Context opens the target, attaches a clean context.md file via the HTML5 DataTransfer API, types a companion prompt in your developer voice, and restores full continuity. Zero copy-pasting.

Code

Shriraj888 / Cross-Context

A local-first LLM context bridge for seamless cross-platform AI conversation transfer.

Cross Context

The Universal Context Bridge & Portability Layer for Large Language Models

📖 What is Cross Context?

Cross Context is an open-source browser extension that eliminates AI vendor lock-in and context fragmentation. When you hit rate limits, context window caps, or want to leverage a different model's strengths, Cross Context captures your active session state and transfers it seamlessly into your target AI platform.

Everything runs 100% locally in your browser sandbox without remote servers, subscription fees, or data collection.

✨ Key Features

🔄 Cross-LLM Continuity: Instantly migrate conversations between Claude, ChatGPT, Gemini, Grok, and Perplexity.
📄 File-Based Context Injection: Generates in-memory context.md files attached directly to target uploaders via the HTML5 DataTransfer API, avoiding bloated chat prompts.
🧠 Optional AI Distillation: Two-pass Gemini synthesis extracts technical facts, active bugs, and architectural decisions, appending the verbatim transcript underneath.
⚡ Zero-Thrashing Scraping: Parses single-page chat UIs with scoped CSS hiding…

View on GitHub

MIT Licensed. The entire codebase is a Chrome MV3 extension — no bundler, no framework, no build step:

File	Role
`background.js`	Service worker: state management, image proxy, Gemini pipeline, cross-tab injection coordinator
`content/content.js`	Monolithic content script: platform-specific DOM scrapers, dual-mode injector, Shadow DOM overlay
`utils/formatter.js`	Markdown assembly and message-boundary truncation
`popup/`	Obsidian Dark + Electric Cyan UI with radar scanner, context cards, and settings modal

How I Built It

The core stack is vanilla JavaScript on Chrome Manifest V3 — zero cloud dependencies, everything runs in the browser sandbox.

┌────────────────────────────────────────────────────────┐
│ UI Layer: Popup (popup.html / popup.js / popup.css)    │
└───────────────────────────┬────────────────────────────┘
                            │ chrome.runtime.sendMessage
┌───────────────────────────▼────────────────────────────┐
│ Background: Service Worker (background.js)             │
│ Storage · Image Proxy · Gemini Pipeline · Coordinator  │
└───────────────────────────┬────────────────────────────┘
                            │ chrome.scripting
┌───────────────────────────▼────────────────────────────┐
│ Content: Single-File Dispatcher (content.js)           │
│ DOM Scrapers · Dual-Mode Injector · Shadow Overlay     │
└────────────────────────────────────────────────────────┘

Four engineering problems had to be solved:

1. Zero-Thrashing DOM Scraping

AI chat UIs use dynamic CSS-in-JS classes, virtualized message lists, and interface chrome (copy buttons, thumbs-up widgets, citation pills) that pollute extracted text. Naive innerText calls trigger layout reflows and freeze the browser on long threads.

Cross Context injects a scoped stylesheet (.cc-scraping-active) that hides non-content elements in a single CSS pass before any DOM read. One reflow, clean extraction, immediate teardown. Each platform gets a tiered fallback selector chain so the extension survives frontend deploys:

Platform	Primary Selector	Fallback
Claude	`[data-testid="user-message"]`	`.font-user-message`, `div[class*="ChatMessage"]`
ChatGPT	`[data-message-author-role]`	`article`, `div.text-base`
Gemini	`user-query`, `model-response`	`message-content`
Grok	`div[data-testid*="message"]`	`div[class*="bubble"]`, `article`
Perplexity	`div[class*="query-wrapper"]`	`div.markdown`, `div[class*="prose"]`

2. Context Engineering — Score, Deduplicate, Truncate

A raw 50-turn chat wastes tokens on greetings, superseded code, and conversational noise. Cross Context runs a local pipeline:

Priority Scoring — Code blocks get +2.5, architecture decisions +2.0, stack traces +2.0. Greetings get −2.0. Messages scoring ≥ 6.0 are kept.
Jaccard Deduplication — When J(A, B) > 0.45 or one code block is a substring of another, the older iteration is pruned. Only the latest, most complete version survives.
Boundary-Safe Truncation — Enforces an 80,000-char safety budget by trimming on whole message boundaries — never splits a code fence mid-token.

3. Two-Pass AI Distillation (Optional, via Gemini API)

When toggled, the extension runs two sequential Gemini calls:

Pass 1 — Structured Extraction: Schema-enforced JSON pulling technical_stack, architecture_decisions, errors_and_issues, pending_tasks, files_mentioned, and important_code.
Pass 2 — Grounded Synthesis: Takes the structured facts + raw transcript and produces a first-person handoff brief ("I was implementing token rotation in client.js...") with the full verbatim transcript appended underneath for ground-truth verification.

Two passes prevent hallucination: Pass 1 constrains facts, Pass 2 can only cite what Pass 1 extracted.

4. Dual-Mode Injection via HTML5 DataTransfer

Pasting 30K characters into a chat box degrades model reasoning. Instead, Cross Context generates an in-memory File object (context-con_01.md) and dispatches synthetic drag-and-drop events directly to the target's file uploader:

const dt = new DataTransfer();
dt.items.add(new File([markdown], fileName, { type: 'text/markdown' }));
// dispatch dragenter → dragover → drop on the target's drop zone

If file drop fails (platform doesn't support it), the injector falls back to native setter override + React synthetic event dispatching to insert text directly into the SPA's input element.

Why Does Open Innovation Matter?

Cross Context could not exist as a closed-source product. Here's why:

1. Breaking walled gardens requires transparency. Every AI vendor profits from keeping your conversation memory locked in their silo. An open-source context bridge is the only kind users can trust not to become another silo. The code is auditable; the extension does what it says.

2. Privacy demands zero-cloud. Developers discuss internal architectures, API keys, and proprietary codebases during AI sessions. A closed sync tool would pipe that through someone else's servers. Cross Context runs entirely in your browser sandbox — no telemetry, no analytics, no external calls (except the optional Gemini API, which you configure with your own key).

3. Open-weight models need open plumbing. Cross Context already bridges to Gemini, which powers Gemma-family models. The same context-engineering pipeline — priority scoring, deduplication, boundary-safe truncation — works identically when handing off to Gemma, Llama, or Mistral running locally via Ollama. A closed API can't let you swap the model underneath; open tools can.

4. Screen time is a design choice. The 30-minute copy-paste ritual exists because vendors don't interoperate. Open innovation removes that friction by design, not by permission. Less friction means faster answers, which means you close the laptop sooner and go touch grass.

My Agent Session

This submission was refined and documented with agentic assistance. The session captures architectural trade-offs, DOM scraper edge-case handling, and the context-engineering iteration process.

Prize Categories

Best Use of Gemma — Cross Context's context-engineering pipeline (scoring, deduplication, truncation) produces model-ready handoff briefs optimized for open-weight models like Gemma. The same context.md format works for local inference via Ollama, making Gemma a first-class handoff target.
Best Use of GitHub Copilot — GitHub Copilot was used throughout development for rapid prototyping of DOM scrapers, selector fallback chains, and the DataTransfer injection logic.

Cross Context: I Built a Universal AI Context Bridge for My Best Friend Who Kept Hitting Model Rate Limits.

Shriraj Patil — Sat, 03 Oct 2026 10:56:52 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

Every developer has been there: it is 1:30 AM, you are deep in the zone debugging a complex race condition across four microservices, and suddenly your screen freezes with:

"You've reached your usage limit until 4:00 AM."

My close friend and hackathon teammate, Rohan, was hitting this wall almost every night. Like thousands of developers, Rohan relies on multiple AI tools: he uses Claude for architectural refactoring, ChatGPT for quick scripting, Gemini for reading massive API documentation, and local models when working offline.

Whenever he hit a rate limit or a context window cap, all of his hard-won state vanished into a closed silo. Switching over to another AI meant spending 20 minutes manually copying code snippets, re-explaining the system architecture, and re-pasting terminal stack traces — burning through context tokens on repetitive conversational fluff before even getting to the actual bug. He was paying for multiple subscriptions and still getting locked out.

I built Cross Context for him.

Cross Context is an open-source, privacy-first browser extension (Manifest V3) that acts as a universal context bridge and portability layer for Large Language Models. With a single click from the extension popup, Cross Context:

Scrapes active session state cleanly from Claude, ChatGPT, Gemini, Grok, or Perplexity with zero layout thrashing.
Applies context engineering heuristics (Jaccard similarity deduplication, technical priority weighting, and boundary-safe truncation) to condense noisy chat threads into a high-density Markdown brief.
Instantly injects the context into destination AI platforms by attaching an in-memory context-con_01.md file directly via the HTML5 DataTransfer API, accompanied by a companion handoff prompt.

When I sent Rohan the unpacked extension build to test on his laptop, he imported an active 22-message debugging thread from Claude directly into ChatGPT in under 3 seconds — complete with active errors and file paths intact. His immediate reaction:

"Dude, you just saved me 40 minutes of re-prompting every night. This is staying pinned in my browser bar forever."

Demo

Here is the high-level workflow of Cross Context in action:

┌────────────────────────┐       ┌────────────────────────┐       ┌────────────────────────┐
│ 1. Active Chat         │  ──>  │ 2. Scrape Context      │  ──>  │ 3. One-Click Injection │
│ (e.g. Claude at limit) │       │ (Local Deduplication)  │       │ (ChatGPT / Gemini /...)│
└────────────────────────┘       └────────────────────────┘       └────────────────────────┘
                                                                               │
                                                                               ▼
                                                                 ┌───────────────────────────┐
                                                                 │ Attached: context-con_01.md│
                                                                 │ + Companion Handoff Prompt│
                                                                 └───────────────────────────┘

Live Website: cross-context.vercel.app
GitHub Repository & Releases: Shriraj888/Cross-Context
Local Quick-Start:
1. Clone https://github.com/Shriraj888/Cross-Context.git.
2. Open chrome://extensions/ in Chrome, Brave, Edge, or Opera.
3. Enable Developer Mode (top-right toggle).
4. Click Load unpacked and select the Cross-Context folder.
5. Open any chat on Claude, ChatGPT, or Gemini, click the extension icon, and hit Scrape Context -> Transfer!

Code

Cross Context is 100% open-source under the permissive MIT License:

Shriraj888 / Cross-Context

A local-first LLM context bridge for seamless cross-platform AI conversation transfer.

Cross Context

The Universal Context Bridge & Portability Layer for Large Language Models

📖 What is Cross Context?

Everything runs 100% locally in your browser sandbox without remote servers, subscription fees, or data collection.

✨ Key Features

🔄 Cross-LLM Continuity: Instantly migrate conversations between Claude, ChatGPT, Gemini, Grok, and Perplexity.
📄 File-Based Context Injection: Generates in-memory context.md files attached directly to target uploaders via the HTML5 DataTransfer API, avoiding bloated chat prompts.
🧠 Optional AI Distillation: Two-pass Gemini synthesis extracts technical facts, active bugs, and architectural decisions, appending the verbatim transcript underneath.
⚡ Zero-Thrashing Scraping: Parses single-page chat UIs with scoped CSS hiding…

View on GitHub

How I Built It

Cross Context is engineered strictly around Chrome Extension Manifest V3 (MV3) with a three-layer decoupled architecture:

┌────────────────────────────────────────────────────────────────────────┐
│                               UI Layer                                 │
│          Popup Window (popup.html, popup.js, popup.css)                │
│   • Active platform detection & radar scan console                     │
│   • Saved contexts list, search, multi-session merger                  │
│   • In-memory Markdown preview (`context.md`) & token estimator       │
│   • Settings modal (Gemini API configuration & model selector)         │
└───────────────────────────────────┬────────────────────────────────────┘
                                    │ (chrome.runtime.sendMessage)
┌───────────────────────────────────▼────────────────────────────────────┐
│                           Background Layer                             │
│               Service Worker Orchestrator (background.js)              │
│   • Central message router & transaction coordinator                   │
│   • Storage management & auto-recovery eviction engine                 │
│   • Two-pass Gemini API enhancement & distillation pipeline            │
│   • Cross-tab injection lifecycle coordinator (`pollAndInject`)        │
│   • Secure CORS image fetch proxy with SSRF validation                 │
└───────────────────────────────────┬────────────────────────────────────┘
                                    │ (chrome.scripting / chrome.tabs)
┌───────────────────────────────────▼────────────────────────────────────┐
│                            Content Layer                               │
│             Single-File Content Script (content/content.js)            │
│   • Platform detection (Claude, ChatGPT, Gemini, Grok, Perplexity)    │
│   • Resilient scraping engine (DOM mutation settling & sanitization)   │
│   • Dual-mode injection engine (file drop & fallback text input)       │
│   • Shadow DOM floating preview confirmation card                      │
└────────────────────────────────────────────────────────────────────────┘

Here are the key subsystems derived from our architectural documentation:

1. Zero-Thrashing Scraper Session (`docs/scraping-engine.md`)

Single-page chat applications are notorious for layout thrashing, virtualized off-screen nodes, and obfuscated CSS-in-JS classes. To scrape cleanly without locking up the browser:

We inject a scoped temporary stylesheet (.cc-scraping-active) that hides non-content chrome (copy buttons, thumbs-up SVGs, action bars, citations) in a single CSS pass.
Reading innerText on the message container extracts clean conversational prose with zero reflows.
The scraper implements a tiered selector fallback chain across all supported platforms (Claude, ChatGPT, Gemini, Grok, and Perplexity).

2. Context Engineering & Deduplication (`docs/context-engineering.md`)

Transferring 10 iterations of the same modified file wastes tokens and confuses the destination model. Cross Context features a specialized local context engine:

Heuristic Priority Scoring: Messages are scored based on technical signal. Code blocks (+2.5), stack traces (+2.0), architectural decisions (+2.0), and task lists (+1.5) are prioritized, while conversational fluff and greetings (-2.0) are dropped.
Jaccard Similarity Deduplication: Extracted code blocks are tokenized into word sets and evaluated via Jaccard distance: $$J(A, B) = \frac{|A \cap B|}{|A \cup B|}$$ If two code snippets share $J(A, B) > 0.45$ or one is a substring of another, only the newest, most complete iteration is preserved.
Boundary-Safe Truncation: To stay within an 80,000-character safety budget (~20,000 tokens), older messages are pruned message-by-message from the transcript head. We never slice raw substrings, preventing unclosed code fences ( ``` ) or malformed Markdown tables.
Sequential Context IDs: Snapshots are automatically tagged (con_01, con_02) so models never confuse separate project sessions.

3. Dual-Mode State Restoration (`docs/injection-engine.md`)

Pasting 5,000 words into a chat prompt triggers aggressive rate limits and degrades attention. Cross Context bypasses this with a two-tier injection strategy:

Mode 1 (File Attachment Injection): Generates an in-memory File object (context-con_01.md) and simulates an HTML5 DataTransfer drag-and-drop event onto the target platform's file uploader. It polls the DOM for the upload chip (e.g. [data-testid="file-chip"]) and then types a concise companion prompt referencing the Context ID.
Mode 2 (SPA Text Fallback): If file uploads are unavailable, it synchronizes with React and Angular Virtual DOMs using synthetic focus, document.execCommand('insertText'), and native prototype setter overrides.

4. Optional Two-Pass AI Distillation (`docs/ai-enhancement-pipeline.md`)

When enabled via user settings, Cross Context leverages Google's Gemini API in a structured two-pass pipeline:

Pass 1: Extracts objective facts (tech stack, architectural decisions, active errors, pending tasks) enforced with strict JSON schemas.
Pass 2: Synthesizes a grounded first-person handoff brief ("I was implementing OAuth login with Supabase when..."), appending the complete verbatim transcript underneath for 100% ground-truth verification.

Why Does Open Innovation Matter?

Open innovation is the entire reason Cross Context exists and why it works better than any proprietary alternative:

Zero-Cloud Privacy & Data Sovereignty: Developer conversations contain sensitive codebases, proprietary API routes, staging URLs, and internal schema keys. Storing conversation histories on a closed third-party synchronization server introduces severe data leakage and compliance risks. Cross Context operates 100% locally in your browser sandbox. Your data never leaves your machine unless you explicitly choose to call an API with your own key.
Defeating AI Vendor Lock-In: Closed commercial AI providers have every incentive to keep your session state locked inside their platforms. If you hit a rate limit, their only solution is to upsell you to a more expensive tier. Open tools give agency back to developers: your context belongs to you, and you should be able to move it freely between any AI model at will.
Synergy with Open-Weight Models: The context snapshots generated by Cross Context (context-con_XX.md) are standard, well-structured Markdown files. They can be piped directly into local open-weight models (such as Gemma, Llama, or Mistral running via Ollama or LM Studio) on an air-gapped laptop with no internet connection at zero cost.
Transparent & Auditable: Browser extensions run with elevated permissions. Because Cross Context is open-source under the MIT license, every developer can inspect the network requests, verify that no keystrokes are tracked, and contribute selector updates as web frontends change.

My Agent Session

This project was built, documented, and refined collaboratively with AI pair programming. You can inspect the development process and tool interactions preserved via DevRelay.

Prize Categories

Best Use of Gemma: Cross Context features a built-in two-pass AI distillation pipeline that transforms noisy conversation threads into dense, schema-enforced handoff briefs and structured JSON facts, supporting lightweight open-weight models and Google AI Studio endpoints.
Best Use of GitHub Copilot: Utilized for rapid generation of DOM selector fallback trees, Chrome Manifest V3 service worker event routing, and cross-platform SPA event dispatch simulations.

DEV Community: Shriraj Patil

EatWise AI: An Open-Source AI Nutrition Companion for Smarter, Healthier Eating

What I Built

EatWise AI — Your Personal AI-Powered Nutrition Companion 🥗🤖

What can you do with EatWise AI?

Demo

Code

How I Built It

Technology Stack

How the AI works

Why this architecture?

Why Does Open Innovation Matter?

My Agent Session

Prize Categories

Submission: Hacktoberfest Open-Source AI Challenge Week 1 (Touch Grass)

What I Built

Why "Touch Grass"?

Who is it for?

Demo

The 3-step handoff:

Code

Shriraj888 / Cross-Context

A local-first LLM context bridge for seamless cross-platform AI conversation transfer.

Cross Context

The Universal Context Bridge & Portability Layer for Large Language Models

📖 What is Cross Context?

✨ Key Features

How I Built It

1. Zero-Thrashing DOM Scraping

2. Context Engineering — Score, Deduplicate, Truncate

3. Two-Pass AI Distillation (Optional, via Gemini API)

4. Dual-Mode Injection via HTML5 DataTransfer

Why Does Open Innovation Matter?

My Agent Session

Prize Categories

Cross Context: I Built a Universal AI Context Bridge for My Best Friend Who Kept Hitting Model Rate Limits.

What I Built

Demo

Code

Shriraj888 / Cross-Context

A local-first LLM context bridge for seamless cross-platform AI conversation transfer.

Cross Context

The Universal Context Bridge & Portability Layer for Large Language Models

📖 What is Cross Context?

✨ Key Features

How I Built It

1. Zero-Thrashing Scraper Session (docs/scraping-engine.md)

2. Context Engineering & Deduplication (docs/context-engineering.md)

3. Dual-Mode State Restoration (docs/injection-engine.md)

4. Optional Two-Pass AI Distillation (docs/ai-enhancement-pipeline.md)

Why Does Open Innovation Matter?

My Agent Session

Prize Categories

1. Zero-Thrashing Scraper Session (`docs/scraping-engine.md`)

2. Context Engineering & Deduplication (`docs/context-engineering.md`)

3. Dual-Mode State Restoration (`docs/injection-engine.md`)

4. Optional Two-Pass AI Distillation (`docs/ai-enhancement-pipeline.md`)