BranchesTags

Repository files navigation

Halftime | As Seen on CBS | Winner @ xAI Hackathon

HalftimeDemo-720p.mov

AI-powered video advertising that actually works. Instead of interrupting viewers with pre-roll ads, we use AI to find natural moments in videos and seamlessly insert personalized ads that feel like part of the show.

What It Does

Halftime analyzes videos using xAI's Grok Vision to find the perfect moment to show an ad—think natural dialogue breaks, scene transitions, or pauses in conversation. Then it uses AI to insert the ad so smoothly that viewers barely notice the transition.

For Viewers:

  • Watch your favorite shows with ads that don't suck
  • Ads appear at natural moments (not mid-sentence)
  • Personalized based on your interests via X API
  • Seamless playback—no buffering, no interruptions

For Advertisers:

  • Real-time analytics dashboard
  • Context-aware ad placement (right audience, right moment)
  • Performance metrics: CTR, engagement, conversions
  • Campaign management tools

How It Works

  1. AI Analysis: Grok Vision analyzes the video transcript + frames to find high-attention moments
  2. Smart Placement: AI scores candidate moments based on context, user interests, and visual flow
  3. Seamless Insertion: Hardware-accelerated video processing inserts ads without re-encoding the entire video
  4. Real-Time Streaming: HLS streaming with dynamic playlist updates—viewers can start watching immediately

Tech Stack

Frontend:

  • Next.js 16 + React 19 + TypeScript
  • Custom HLS video player with real-time ad markers
  • Tailwind CSS for responsive design
  • Recharts for analytics visualization

Backend:

  • Python 3.13 + FastAPI for high-performance API
  • FFmpeg hardware acceleration (VideoToolbox)
  • Supabase for auth + database
  • Real-time HLS streaming

AI & APIs:

  • xAI Grok Vision (video + transcript analysis)
  • WaveSpeed AI (video generation)
  • X API (audience personalization)
  • OMDb (movie metadata)

Key Features

  • Two-Stage AI Analysis: Transcript parsing + visual verification for optimal placement
  • Hardware Acceleration: 3-5 minute processing for 43-minute videos
  • Dual Frontends: Viewer platform + advertiser dashboard
  • Real-Time Analytics: Track impressions, clicks, conversions, engagement
  • Personalized Targeting: Uses X API signals for context-aware ads
  • Zero-Wait Streaming: Watch while processing happens in background

Performance

  • Processes 43-minute videos in 3-5 minutes with hardware acceleration
  • Dynamic HLS playlist updates for seamless viewing
  • Real-time ad tracking and analytics
  • Multi-tenant architecture supporting multiple advertisers

Architecture

┌─────────────────────────────────────────────────┐
│ Viewer App (Next.js) | Dashboard (Next.js) │
│ - Video Player | - Analytics │
│ - Ad Tracking | - Campaigns │
└──────────────────┬──────────────────────────────┘
│
┌─────────▼─────────┐
│ FastAPI Backend │
│ - Auth │
│ - Video Jobs │
│ - HLS Streaming │
└─────────┬─────────┘
│
┌──────────────┼──────────────┐
│ │ │
┌───▼───┐ ┌─────▼─────┐ ┌───▼────┐
│ Grok │ │ WaveSpeed │ │ X │
│ Vision│ │ AI (Wan2) │ │ API │
└───────┘ └───────────┘ └────────┘

Getting Started

Prerequisites

  • Node.js 18+
  • Python 3.13+
  • FFmpeg installed

Environment Setup

# Required API keys
XAI_API_KEY=your_grok_api_key
WAVESPEED_API_KEY=your_wavespeed_key
X_BEARER_TOKEN=your_x_api_token
SUPABASE_URL=your_supabase_url
SUPABASE_SERVICE_KEY=your_supabase_key

Run Viewer Platform

cd frontend/xvideos
npm install
npm run dev

Run Dashboard

cd frontend/dashboard
npm install
npm run dev

Run Backend API

cd backend/dashboard
pip install -r requirements.txt
uvicorn app.main:app --reload

Why Halftime?

Traditional video ads are broken:

  • ❌ Pre-roll ads annoy viewers before content even starts
  • ❌ Mid-roll ads interrupt at random, jarring moments
  • ❌ Static ads ignore viewer preferences and context
  • ❌ Poor targeting leads to wasted ad spend

Halftime fixes this:

  • ✅ AI finds natural moments that don't disrupt flow
  • ✅ Visual verification ensures placements make sense
  • ✅ Personalized targeting based on user interests
  • ✅ Real-time analytics for advertisers
  • ✅ Seamless viewing experience for audiences

Built with ❤️ using xAI Grok Vision, Next.js, Python, and a lot of FFmpeg magic.

About

No description, website, or topics provided.

Resources

Readme
Activity
Custom properties

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Add copy buttons to all 
 blocks\n(function() {\n function addCopyButtons() {\n document.querySelectorAll('pre code').forEach(function(codeBlock) {\n if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;\n codeBlock.parentElement.setAttribute('data-copy-added', 'true');\n \n var btn = document.createElement('button');\n btn.textContent = 'Copy';\n btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';\n btn.onmouseover = function() { this.style.opacity = '1'; };\n btn.onmouseout = function() { this.style.opacity = '0.7'; };\n btn.onclick = function() {\n navigator.clipboard.writeText(codeBlock.textContent).then(function() {\n btn.textContent = 'Copied!';\n setTimeout(function() { btn.textContent = 'Copy'; }, 1500);\n });\n };\n codeBlock.parentElement.style.position = 'relative';\n codeBlock.parentElement.appendChild(btn);\n });\n }\n \n addCopyButtons();\n \n // Re-run on dynamic content\n var observer = new MutationObserver(addCopyButtons);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Add Copy Buttons to Code Blocks");
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
BranchesTags
Repository files navigation
Halftime | As Seen on CBS | Winner @ xAI Hackathon
HalftimeDemo-720p.mov
AI-powered video advertising that actually works. Instead of interrupting viewers with pre-roll ads, we use AI to find natural moments in videos and seamlessly insert personalized ads that feel like part of the show.
What It Does
Halftime analyzes videos using xAI's Grok Vision to find the perfect moment to show an ad—think natural dialogue breaks, scene transitions, or pauses in conversation. Then it uses AI to insert the ad so smoothly that viewers barely notice the transition.
For Viewers:
  • Watch your favorite shows with ads that don't suck
  • Ads appear at natural moments (not mid-sentence)
  • Personalized based on your interests via X API
  • Seamless playback—no buffering, no interruptions
For Advertisers:
  • Real-time analytics dashboard
  • Context-aware ad placement (right audience, right moment)
  • Performance metrics: CTR, engagement, conversions
  • Campaign management tools
How It Works
  1. AI Analysis: Grok Vision analyzes the video transcript + frames to find high-attention moments
  2. Smart Placement: AI scores candidate moments based on context, user interests, and visual flow
  3. Seamless Insertion: Hardware-accelerated video processing inserts ads without re-encoding the entire video
  4. Real-Time Streaming: HLS streaming with dynamic playlist updates—viewers can start watching immediately
Tech Stack
Frontend:
  • Next.js 16 + React 19 + TypeScript
  • Custom HLS video player with real-time ad markers
  • Tailwind CSS for responsive design
  • Recharts for analytics visualization
Backend:
  • Python 3.13 + FastAPI for high-performance API
  • FFmpeg hardware acceleration (VideoToolbox)
  • Supabase for auth + database
  • Real-time HLS streaming
AI & APIs:
  • xAI Grok Vision (video + transcript analysis)
  • WaveSpeed AI (video generation)
  • X API (audience personalization)
  • OMDb (movie metadata)
Key Features
  • Two-Stage AI Analysis: Transcript parsing + visual verification for optimal placement
  • Hardware Acceleration: 3-5 minute processing for 43-minute videos
  • Dual Frontends: Viewer platform + advertiser dashboard
  • Real-Time Analytics: Track impressions, clicks, conversions, engagement
  • Personalized Targeting: Uses X API signals for context-aware ads
  • Zero-Wait Streaming: Watch while processing happens in background
Performance
  • Processes 43-minute videos in 3-5 minutes with hardware acceleration
  • Dynamic HLS playlist updates for seamless viewing
  • Real-time ad tracking and analytics
  • Multi-tenant architecture supporting multiple advertisers
Architecture
┌─────────────────────────────────────────────────┐
│ Viewer App (Next.js) | Dashboard (Next.js) │
│ - Video Player | - Analytics │
│ - Ad Tracking | - Campaigns │
└──────────────────┬──────────────────────────────┘
│
┌─────────▼─────────┐
│ FastAPI Backend │
│ - Auth │
│ - Video Jobs │
│ - HLS Streaming │
└─────────┬─────────┘
│
┌──────────────┼──────────────┐
│ │ │
┌───▼───┐ ┌─────▼─────┐ ┌───▼────┐
│ Grok │ │ WaveSpeed │ │ X │
│ Vision│ │ AI (Wan2) │ │ API │
└───────┘ └───────────┘ └────────┘

Getting Started
Prerequisites
  • Node.js 18+
  • Python 3.13+
  • FFmpeg installed
Environment Setup
# Required API keys
XAI_API_KEY=your_grok_api_key
WAVESPEED_API_KEY=your_wavespeed_key
X_BEARER_TOKEN=your_x_api_token
SUPABASE_URL=your_supabase_url
SUPABASE_SERVICE_KEY=your_supabase_key
Run Viewer Platform
cd frontend/xvideos
npm install
npm run dev
Run Dashboard
cd frontend/dashboard
npm install
npm run dev
Run Backend API
cd backend/dashboard
pip install -r requirements.txt
uvicorn app.main:app --reload
Why Halftime?
Traditional video ads are broken:
  • ❌ Pre-roll ads annoy viewers before content even starts
  • ❌ Mid-roll ads interrupt at random, jarring moments
  • ❌ Static ads ignore viewer preferences and context
  • ❌ Poor targeting leads to wasted ad spend
Halftime fixes this:
  • ✅ AI finds natural moments that don't disrupt flow
  • ✅ Visual verification ensures placements make sense
  • ✅ Personalized targeting based on user interests
  • ✅ Real-time analytics for advertisers
  • ✅ Seamless viewing experience for audiences
Built with ❤️ using xAI Grok Vision, Next.js, Python, and a lot of FFmpeg magic.
About
No description, website, or topics provided.
Resources
Readme
Activity
Custom properties
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Force GitHub README to respect dark mode\n(function() {\n var style = document.createElement('style');\n style.textContent = '\n .markdown-body {\n color-scheme: dark light;\n }\n .markdown-body pre { background: #161b22 !important; }\n .markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }\n .markdown-body table th, .markdown-body table td { border-color: #30363d !important; }\n .markdown-body img { background: #0d1117; }\n .markdown-body blockquote { border-left-color: #8b949e; }\n .markdown-body hr { border-color: #30363d; }\n ';\n document.head.appendChild(style);\n})();", "GitHub Dark Mode README Fix");
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
Halftime | As Seen on CBS | Winner @ xAI Hackathon
HalftimeDemo-720p.mov
AI-powered video advertising that actually works. Instead of interrupting viewers with pre-roll ads, we use AI to find natural moments in videos and seamlessly insert personalized ads that feel like part of the show.
What It Does
Halftime analyzes videos using xAI's Grok Vision to find the perfect moment to show an ad—think natural dialogue breaks, scene transitions, or pauses in conversation. Then it uses AI to insert the ad so smoothly that viewers barely notice the transition.
For Viewers:
  • Watch your favorite shows with ads that don't suck
  • Ads appear at natural moments (not mid-sentence)
  • Personalized based on your interests via X API
  • Seamless playback—no buffering, no interruptions
For Advertisers:
  • Real-time analytics dashboard
  • Context-aware ad placement (right audience, right moment)
  • Performance metrics: CTR, engagement, conversions
  • Campaign management tools
How It Works
  1. AI Analysis: Grok Vision analyzes the video transcript + frames to find high-attention moments
  2. Smart Placement: AI scores candidate moments based on context, user interests, and visual flow
  3. Seamless Insertion: Hardware-accelerated video processing inserts ads without re-encoding the entire video
  4. Real-Time Streaming: HLS streaming with dynamic playlist updates—viewers can start watching immediately
Tech Stack
Frontend:
  • Next.js 16 + React 19 + TypeScript
  • Custom HLS video player with real-time ad markers
  • Tailwind CSS for responsive design
  • Recharts for analytics visualization
Backend:
  • Python 3.13 + FastAPI for high-performance API
  • FFmpeg hardware acceleration (VideoToolbox)
  • Supabase for auth + database
  • Real-time HLS streaming
AI & APIs:
  • xAI Grok Vision (video + transcript analysis)
  • WaveSpeed AI (video generation)
  • X API (audience personalization)
  • OMDb (movie metadata)
Key Features
  • Two-Stage AI Analysis: Transcript parsing + visual verification for optimal placement
  • Hardware Acceleration: 3-5 minute processing for 43-minute videos
  • Dual Frontends: Viewer platform + advertiser dashboard
  • Real-Time Analytics: Track impressions, clicks, conversions, engagement
  • Personalized Targeting: Uses X API signals for context-aware ads
  • Zero-Wait Streaming: Watch while processing happens in background
Performance
  • Processes 43-minute videos in 3-5 minutes with hardware acceleration
  • Dynamic HLS playlist updates for seamless viewing
  • Real-time ad tracking and analytics
  • Multi-tenant architecture supporting multiple advertisers
Architecture
┌─────────────────────────────────────────────────┐
│ Viewer App (Next.js) | Dashboard (Next.js) │
│ - Video Player | - Analytics │
│ - Ad Tracking | - Campaigns │
└──────────────────┬──────────────────────────────┘
│
┌─────────▼─────────┐
│ FastAPI Backend │
│ - Auth │
│ - Video Jobs │
│ - HLS Streaming │
└─────────┬─────────┘
│
┌──────────────┼──────────────┐
│ │ │
┌───▼───┐ ┌─────▼─────┐ ┌───▼────┐
│ Grok │ │ WaveSpeed │ │ X │
│ Vision│ │ AI (Wan2) │ │ API │
└───────┘ └───────────┘ └────────┘

Getting Started
Prerequisites
  • Node.js 18+
  • Python 3.13+
  • FFmpeg installed
Environment Setup
# Required API keys
XAI_API_KEY=your_grok_api_key
WAVESPEED_API_KEY=your_wavespeed_key
X_BEARER_TOKEN=your_x_api_token
SUPABASE_URL=your_supabase_url
SUPABASE_SERVICE_KEY=your_supabase_key
Run Viewer Platform
cd frontend/xvideos
npm install
npm run dev
Run Dashboard
cd frontend/dashboard
npm install
npm run dev
Run Backend API
cd backend/dashboard
pip install -r requirements.txt
uvicorn app.main:app --reload
Why Halftime?
Traditional video ads are broken:
  • ❌ Pre-roll ads annoy viewers before content even starts
  • ❌ Mid-roll ads interrupt at random, jarring moments
  • ❌ Static ads ignore viewer preferences and context
  • ❌ Poor targeting leads to wasted ad spend
Halftime fixes this:
  • ✅ AI finds natural moments that don't disrupt flow
  • ✅ Visual verification ensures placements make sense
  • ✅ Personalized targeting based on user interests
  • ✅ Real-time analytics for advertisers
  • ✅ Seamless viewing experience for audiences
Built with ❤️ using xAI Grok Vision, Next.js, Python, and a lot of FFmpeg magic.
About
No description, website, or topics provided.
Resources
Readme
Activity
Custom properties
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Highlight search terms from Google/DuckDuckGo/Bing referrer\n(function() {\n var ref = document.referrer;\n var terms = [];\n \n if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {\n var url = new URL(ref);\n var q = url.searchParams.get('q') || url.searchParams.get('p');\n if (q) {\n terms = q.split(/\\s+/).filter(function(t) { return t.length > 2; });\n }\n }\n \n if (terms.length === 0) return;\n \n var style = document.createElement('style');\n style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';\n document.head.appendChild(style);\n \n function highlight(node) {\n if (node.nodeType === 3) { // text node\n var text = node.textContent;\n var found = false;\n terms.forEach(function(term) {\n var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\') + ')', 'gi');\n if (regex.test(text)) {\n found = true;\n var frag = document.createDocumentFragment();\n var parts = text.split(regex);\n parts.forEach(function(part, i) {\n if (i % 2 === 0) {\n frag.appendChild(document.createTextNode(part));\n } else {\n var span = document.createElement('span');\n span.className = 'userscript-highlight';\n span.textContent = part;\n frag.appendChild(span);\n }\n });\n node.parentNode.replaceChild(frag, node);\n }\n });\n } else if (node.nodeType === 1 && node.childNodes) { // element\n var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];\n if (!skipTags.includes(node.tagName)) {\n Array.from(node.childNodes).forEach(highlight);\n }\n }\n }\n \n highlight(document.body);\n \n // Re-highlight on dynamic content\n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1 || node.nodeType === 3) highlight(node);\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Highlight Search Terms");
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
Halftime | As Seen on CBS | Winner @ xAI Hackathon
HalftimeDemo-720p.mov
AI-powered video advertising that actually works. Instead of interrupting viewers with pre-roll ads, we use AI to find natural moments in videos and seamlessly insert personalized ads that feel like part of the show.
What It Does
Halftime analyzes videos using xAI's Grok Vision to find the perfect moment to show an ad—think natural dialogue breaks, scene transitions, or pauses in conversation. Then it uses AI to insert the ad so smoothly that viewers barely notice the transition.
For Viewers:
  • Watch your favorite shows with ads that don't suck
  • Ads appear at natural moments (not mid-sentence)
  • Personalized based on your interests via X API
  • Seamless playback—no buffering, no interruptions
For Advertisers:
  • Real-time analytics dashboard
  • Context-aware ad placement (right audience, right moment)
  • Performance metrics: CTR, engagement, conversions
  • Campaign management tools
How It Works
  1. AI Analysis: Grok Vision analyzes the video transcript + frames to find high-attention moments
  2. Smart Placement: AI scores candidate moments based on context, user interests, and visual flow
  3. Seamless Insertion: Hardware-accelerated video processing inserts ads without re-encoding the entire video
  4. Real-Time Streaming: HLS streaming with dynamic playlist updates—viewers can start watching immediately
Tech Stack
Frontend:
  • Next.js 16 + React 19 + TypeScript
  • Custom HLS video player with real-time ad markers
  • Tailwind CSS for responsive design
  • Recharts for analytics visualization
Backend:
  • Python 3.13 + FastAPI for high-performance API
  • FFmpeg hardware acceleration (VideoToolbox)
  • Supabase for auth + database
  • Real-time HLS streaming
AI & APIs:
  • xAI Grok Vision (video + transcript analysis)
  • WaveSpeed AI (video generation)
  • X API (audience personalization)
  • OMDb (movie metadata)
Key Features
  • Two-Stage AI Analysis: Transcript parsing + visual verification for optimal placement
  • Hardware Acceleration: 3-5 minute processing for 43-minute videos
  • Dual Frontends: Viewer platform + advertiser dashboard
  • Real-Time Analytics: Track impressions, clicks, conversions, engagement
  • Personalized Targeting: Uses X API signals for context-aware ads
  • Zero-Wait Streaming: Watch while processing happens in background
Performance
  • Processes 43-minute videos in 3-5 minutes with hardware acceleration
  • Dynamic HLS playlist updates for seamless viewing
  • Real-time ad tracking and analytics
  • Multi-tenant architecture supporting multiple advertisers
Architecture
┌─────────────────────────────────────────────────┐
│ Viewer App (Next.js) | Dashboard (Next.js) │
│ - Video Player | - Analytics │
│ - Ad Tracking | - Campaigns │
└──────────────────┬──────────────────────────────┘
│
┌─────────▼─────────┐
│ FastAPI Backend │
│ - Auth │
│ - Video Jobs │
│ - HLS Streaming │
└─────────┬─────────┘
│
┌──────────────┼──────────────┐
│ │ │
┌───▼───┐ ┌─────▼─────┐ ┌───▼────┐
│ Grok │ │ WaveSpeed │ │ X │
│ Vision│ │ AI (Wan2) │ │ API │
└───────┘ └───────────┘ └────────┘

Getting Started
Prerequisites
  • Node.js 18+
  • Python 3.13+
  • FFmpeg installed
Environment Setup
# Required API keys
XAI_API_KEY=your_grok_api_key
WAVESPEED_API_KEY=your_wavespeed_key
X_BEARER_TOKEN=your_x_api_token
SUPABASE_URL=your_supabase_url
SUPABASE_SERVICE_KEY=your_supabase_key
Run Viewer Platform
cd frontend/xvideos
npm install
npm run dev
Run Dashboard
cd frontend/dashboard
npm install
npm run dev
Run Backend API
cd backend/dashboard
pip install -r requirements.txt
uvicorn app.main:app --reload
Why Halftime?
Traditional video ads are broken:
  • ❌ Pre-roll ads annoy viewers before content even starts
  • ❌ Mid-roll ads interrupt at random, jarring moments
  • ❌ Static ads ignore viewer preferences and context
  • ❌ Poor targeting leads to wasted ad spend
Halftime fixes this:
  • ✅ AI finds natural moments that don't disrupt flow
  • ✅ Visual verification ensures placements make sense
  • ✅ Personalized targeting based on user interests
  • ✅ Real-time analytics for advertisers
  • ✅ Seamless viewing experience for audiences
Built with ❤️ using xAI Grok Vision, Next.js, Python, and a lot of FFmpeg magic.
About
No description, website, or topics provided.
Resources
Readme
Activity
Custom properties
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Strip utm_, fbclid, gclid, etc. from all links on page\n(function() {\n var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',\n 'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',\n 'ref', 'ref_src', 'source', 'medium', 'campaign'];\n \n function cleanUrl(url) {\n try {\n var u = new URL(url, window.location.origin);\n var changed = false;\n trackingParams.forEach(function(p) {\n if (u.searchParams.has(p)) {\n u.searchParams.delete(p);\n changed = true;\n }\n });\n return changed ? u.toString() : url;\n } catch (e) {\n return url;\n }\n }\n \n function cleanLinks() {\n document.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n \n cleanLinks();\n \n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1) {\n if (node.tagName === 'A') cleanLinks();\n node.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Remove Tracking Parameters from Links");
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
BranchesTags
Repository files navigation
Halftime | As Seen on CBS | Winner @ xAI Hackathon
HalftimeDemo-720p.mov
AI-powered video advertising that actually works. Instead of interrupting viewers with pre-roll ads, we use AI to find natural moments in videos and seamlessly insert personalized ads that feel like part of the show.
What It Does
Halftime analyzes videos using xAI's Grok Vision to find the perfect moment to show an ad—think natural dialogue breaks, scene transitions, or pauses in conversation. Then it uses AI to insert the ad so smoothly that viewers barely notice the transition.
For Viewers:
  • Watch your favorite shows with ads that don't suck
  • Ads appear at natural moments (not mid-sentence)
  • Personalized based on your interests via X API
  • Seamless playback—no buffering, no interruptions
For Advertisers:
  • Real-time analytics dashboard
  • Context-aware ad placement (right audience, right moment)
  • Performance metrics: CTR, engagement, conversions
  • Campaign management tools
How It Works
  1. AI Analysis: Grok Vision analyzes the video transcript + frames to find high-attention moments
  2. Smart Placement: AI scores candidate moments based on context, user interests, and visual flow
  3. Seamless Insertion: Hardware-accelerated video processing inserts ads without re-encoding the entire video
  4. Real-Time Streaming: HLS streaming with dynamic playlist updates—viewers can start watching immediately
Tech Stack
Frontend:
  • Next.js 16 + React 19 + TypeScript
  • Custom HLS video player with real-time ad markers
  • Tailwind CSS for responsive design
  • Recharts for analytics visualization
Backend:
  • Python 3.13 + FastAPI for high-performance API
  • FFmpeg hardware acceleration (VideoToolbox)
  • Supabase for auth + database
  • Real-time HLS streaming
AI & APIs:
  • xAI Grok Vision (video + transcript analysis)
  • WaveSpeed AI (video generation)
  • X API (audience personalization)
  • OMDb (movie metadata)
Key Features
  • Two-Stage AI Analysis: Transcript parsing + visual verification for optimal placement
  • Hardware Acceleration: 3-5 minute processing for 43-minute videos
  • Dual Frontends: Viewer platform + advertiser dashboard
  • Real-Time Analytics: Track impressions, clicks, conversions, engagement
  • Personalized Targeting: Uses X API signals for context-aware ads
  • Zero-Wait Streaming: Watch while processing happens in background
Performance
  • Processes 43-minute videos in 3-5 minutes with hardware acceleration
  • Dynamic HLS playlist updates for seamless viewing
  • Real-time ad tracking and analytics
  • Multi-tenant architecture supporting multiple advertisers
Architecture
┌─────────────────────────────────────────────────┐
│ Viewer App (Next.js) | Dashboard (Next.js) │
│ - Video Player | - Analytics │
│ - Ad Tracking | - Campaigns │
└──────────────────┬──────────────────────────────┘
│
┌─────────▼─────────┐
│ FastAPI Backend │
│ - Auth │
│ - Video Jobs │
│ - HLS Streaming │
└─────────┬─────────┘
│
┌──────────────┼──────────────┐
│ │ │
┌───▼───┐ ┌─────▼─────┐ ┌───▼────┐
│ Grok │ │ WaveSpeed │ │ X │
│ Vision│ │ AI (Wan2) │ │ API │
└───────┘ └───────────┘ └────────┘

Getting Started
Prerequisites
  • Node.js 18+
  • Python 3.13+
  • FFmpeg installed
Environment Setup
# Required API keys
XAI_API_KEY=your_grok_api_key
WAVESPEED_API_KEY=your_wavespeed_key
X_BEARER_TOKEN=your_x_api_token
SUPABASE_URL=your_supabase_url
SUPABASE_SERVICE_KEY=your_supabase_key
Run Viewer Platform
cd frontend/xvideos
npm install
npm run dev
Run Dashboard
cd frontend/dashboard
npm install
npm run dev
Run Backend API
cd backend/dashboard
pip install -r requirements.txt
uvicorn app.main:app --reload
Why Halftime?
Traditional video ads are broken:
  • ❌ Pre-roll ads annoy viewers before content even starts
  • ❌ Mid-roll ads interrupt at random, jarring moments
  • ❌ Static ads ignore viewer preferences and context
  • ❌ Poor targeting leads to wasted ad spend
Halftime fixes this:
  • ✅ AI finds natural moments that don't disrupt flow
  • ✅ Visual verification ensures placements make sense
  • ✅ Personalized targeting based on user interests
  • ✅ Real-time analytics for advertisers
  • ✅ Seamless viewing experience for audiences
Built with ❤️ using xAI Grok Vision, Next.js, Python, and a lot of FFmpeg magic.
About
No description, website, or topics provided.
Resources
Readme
Activity
Custom properties
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Auto-enable theater mode on YouTube\n(function() {\n function tryTheater() {\n var btn = document.querySelector('button[aria-label=\"Theater mode\"], ytd-player #player button[title=\"Theater mode\"]');\n if (btn && !btn.classList.contains('activated')) {\n btn.click();\n }\n }\n \n // Try immediately\n tryTheater();\n \n // Try after navigation (SPA)\n var lastUrl = location.href;\n setInterval(function() {\n if (location.href !== lastUrl) {\n lastUrl = location.href;\n setTimeout(tryTheater, 500);\n }\n }, 1000);\n \n // Also try on player load\n var observer = new MutationObserver(tryTheater);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "YouTube Theater Mode Default");
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
Halftime | As Seen on CBS | Winner @ xAI Hackathon
HalftimeDemo-720p.mov
AI-powered video advertising that actually works. Instead of interrupting viewers with pre-roll ads, we use AI to find natural moments in videos and seamlessly insert personalized ads that feel like part of the show.
What It Does
Halftime analyzes videos using xAI's Grok Vision to find the perfect moment to show an ad—think natural dialogue breaks, scene transitions, or pauses in conversation. Then it uses AI to insert the ad so smoothly that viewers barely notice the transition.
For Viewers:
  • Watch your favorite shows with ads that don't suck
  • Ads appear at natural moments (not mid-sentence)
  • Personalized based on your interests via X API
  • Seamless playback—no buffering, no interruptions
For Advertisers:
  • Real-time analytics dashboard
  • Context-aware ad placement (right audience, right moment)
  • Performance metrics: CTR, engagement, conversions
  • Campaign management tools
How It Works
  1. AI Analysis: Grok Vision analyzes the video transcript + frames to find high-attention moments
  2. Smart Placement: AI scores candidate moments based on context, user interests, and visual flow
  3. Seamless Insertion: Hardware-accelerated video processing inserts ads without re-encoding the entire video
  4. Real-Time Streaming: HLS streaming with dynamic playlist updates—viewers can start watching immediately
Tech Stack
Frontend:
  • Next.js 16 + React 19 + TypeScript
  • Custom HLS video player with real-time ad markers
  • Tailwind CSS for responsive design
  • Recharts for analytics visualization
Backend:
  • Python 3.13 + FastAPI for high-performance API
  • FFmpeg hardware acceleration (VideoToolbox)
  • Supabase for auth + database
  • Real-time HLS streaming
AI & APIs:
  • xAI Grok Vision (video + transcript analysis)
  • WaveSpeed AI (video generation)
  • X API (audience personalization)
  • OMDb (movie metadata)
Key Features
  • Two-Stage AI Analysis: Transcript parsing + visual verification for optimal placement
  • Hardware Acceleration: 3-5 minute processing for 43-minute videos
  • Dual Frontends: Viewer platform + advertiser dashboard
  • Real-Time Analytics: Track impressions, clicks, conversions, engagement
  • Personalized Targeting: Uses X API signals for context-aware ads
  • Zero-Wait Streaming: Watch while processing happens in background
Performance
  • Processes 43-minute videos in 3-5 minutes with hardware acceleration
  • Dynamic HLS playlist updates for seamless viewing
  • Real-time ad tracking and analytics
  • Multi-tenant architecture supporting multiple advertisers
Architecture
┌─────────────────────────────────────────────────┐
│ Viewer App (Next.js) | Dashboard (Next.js) │
│ - Video Player | - Analytics │
│ - Ad Tracking | - Campaigns │
└──────────────────┬──────────────────────────────┘
│
┌─────────▼─────────┐
│ FastAPI Backend │
│ - Auth │
│ - Video Jobs │
│ - HLS Streaming │
└─────────┬─────────┘
│
┌──────────────┼──────────────┐
│ │ │
┌───▼───┐ ┌─────▼─────┐ ┌───▼────┐
│ Grok │ │ WaveSpeed │ │ X │
│ Vision│ │ AI (Wan2) │ │ API │
└───────┘ └───────────┘ └────────┘

Getting Started
Prerequisites
  • Node.js 18+
  • Python 3.13+
  • FFmpeg installed
Environment Setup
# Required API keys
XAI_API_KEY=your_grok_api_key
WAVESPEED_API_KEY=your_wavespeed_key
X_BEARER_TOKEN=your_x_api_token
SUPABASE_URL=your_supabase_url
SUPABASE_SERVICE_KEY=your_supabase_key
Run Viewer Platform
cd frontend/xvideos
npm install
npm run dev
Run Dashboard
cd frontend/dashboard
npm install
npm run dev
Run Backend API
cd backend/dashboard
pip install -r requirements.txt
uvicorn app.main:app --reload
Why Halftime?
Traditional video ads are broken:
  • ❌ Pre-roll ads annoy viewers before content even starts
  • ❌ Mid-roll ads interrupt at random, jarring moments
  • ❌ Static ads ignore viewer preferences and context
  • ❌ Poor targeting leads to wasted ad spend
Halftime fixes this:
  • ✅ AI finds natural moments that don't disrupt flow
  • ✅ Visual verification ensures placements make sense
  • ✅ Personalized targeting based on user interests
  • ✅ Real-time analytics for advertisers
  • ✅ Seamless viewing experience for audiences
Built with ❤️ using xAI Grok Vision, Next.js, Python, and a lot of FFmpeg magic.
About
No description, website, or topics provided.
Resources
Readme
Activity
Custom properties
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Remove or un-stick sticky/fixed headers that block content\n(function() {\n function unstick() {\n document.querySelectorAll('header, nav, [role=\"banner\"], .header, .navbar, .sticky, .fixed-top, [style*=\"position: fixed\"], [style*=\"position:sticky\"]').forEach(function(el) {\n if (el.style.position === 'fixed' || el.style.position === 'sticky' || \n getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {\n el.style.position = 'static';\n el.style.top = 'auto';\n el.style.zIndex = 'auto';\n }\n });\n }\n \n unstick();\n \n var observer = new MutationObserver(unstick);\n observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });\n})();", "Kill Sticky Headers");
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
Halftime | As Seen on CBS | Winner @ xAI Hackathon
HalftimeDemo-720p.mov
AI-powered video advertising that actually works. Instead of interrupting viewers with pre-roll ads, we use AI to find natural moments in videos and seamlessly insert personalized ads that feel like part of the show.
What It Does
Halftime analyzes videos using xAI's Grok Vision to find the perfect moment to show an ad—think natural dialogue breaks, scene transitions, or pauses in conversation. Then it uses AI to insert the ad so smoothly that viewers barely notice the transition.
For Viewers:
  • Watch your favorite shows with ads that don't suck
  • Ads appear at natural moments (not mid-sentence)
  • Personalized based on your interests via X API
  • Seamless playback—no buffering, no interruptions
For Advertisers:
  • Real-time analytics dashboard
  • Context-aware ad placement (right audience, right moment)
  • Performance metrics: CTR, engagement, conversions
  • Campaign management tools
How It Works
  1. AI Analysis: Grok Vision analyzes the video transcript + frames to find high-attention moments
  2. Smart Placement: AI scores candidate moments based on context, user interests, and visual flow
  3. Seamless Insertion: Hardware-accelerated video processing inserts ads without re-encoding the entire video
  4. Real-Time Streaming: HLS streaming with dynamic playlist updates—viewers can start watching immediately
Tech Stack
Frontend:
  • Next.js 16 + React 19 + TypeScript
  • Custom HLS video player with real-time ad markers
  • Tailwind CSS for responsive design
  • Recharts for analytics visualization
Backend:
  • Python 3.13 + FastAPI for high-performance API
  • FFmpeg hardware acceleration (VideoToolbox)
  • Supabase for auth + database
  • Real-time HLS streaming
AI & APIs:
  • xAI Grok Vision (video + transcript analysis)
  • WaveSpeed AI (video generation)
  • X API (audience personalization)
  • OMDb (movie metadata)
Key Features
  • Two-Stage AI Analysis: Transcript parsing + visual verification for optimal placement
  • Hardware Acceleration: 3-5 minute processing for 43-minute videos
  • Dual Frontends: Viewer platform + advertiser dashboard
  • Real-Time Analytics: Track impressions, clicks, conversions, engagement
  • Personalized Targeting: Uses X API signals for context-aware ads
  • Zero-Wait Streaming: Watch while processing happens in background
Performance
  • Processes 43-minute videos in 3-5 minutes with hardware acceleration
  • Dynamic HLS playlist updates for seamless viewing
  • Real-time ad tracking and analytics
  • Multi-tenant architecture supporting multiple advertisers
Architecture
┌─────────────────────────────────────────────────┐
│ Viewer App (Next.js) | Dashboard (Next.js) │
│ - Video Player | - Analytics │
│ - Ad Tracking | - Campaigns │
└──────────────────┬──────────────────────────────┘
│
┌─────────▼─────────┐
│ FastAPI Backend │
│ - Auth │
│ - Video Jobs │
│ - HLS Streaming │
└─────────┬─────────┘
│
┌──────────────┼──────────────┐
│ │ │
┌───▼───┐ ┌─────▼─────┐ ┌───▼────┐
│ Grok │ │ WaveSpeed │ │ X │
│ Vision│ │ AI (Wan2) │ │ API │
└───────┘ └───────────┘ └────────┘

Getting Started
Prerequisites
  • Node.js 18+
  • Python 3.13+
  • FFmpeg installed
Environment Setup
# Required API keys
XAI_API_KEY=your_grok_api_key
WAVESPEED_API_KEY=your_wavespeed_key
X_BEARER_TOKEN=your_x_api_token
SUPABASE_URL=your_supabase_url
SUPABASE_SERVICE_KEY=your_supabase_key
Run Viewer Platform
cd frontend/xvideos
npm install
npm run dev
Run Dashboard
cd frontend/dashboard
npm install
npm run dev
Run Backend API
cd backend/dashboard
pip install -r requirements.txt
uvicorn app.main:app --reload
Why Halftime?
Traditional video ads are broken:
  • ❌ Pre-roll ads annoy viewers before content even starts
  • ❌ Mid-roll ads interrupt at random, jarring moments
  • ❌ Static ads ignore viewer preferences and context
  • ❌ Poor targeting leads to wasted ad spend
Halftime fixes this:
  • ✅ AI finds natural moments that don't disrupt flow
  • ✅ Visual verification ensures placements make sense
  • ✅ Personalized targeting based on user interests
  • ✅ Real-time analytics for advertisers
  • ✅ Seamless viewing experience for audiences
Built with ❤️ using xAI Grok Vision, Next.js, Python, and a lot of FFmpeg magic.
About
No description, website, or topics provided.
Resources
Readme
Activity
Custom properties
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Universal Dark Mode - works on any site\n(function() {\n var enabled = true;\n \n function applyDarkMode() {\n if (!enabled) return;\n \n // Create style element if it doesn't exist\n var style = document.getElementById('universal-dark-mode-style');\n if (!style) {\n style = document.createElement('style');\n style.id = 'universal-dark-mode-style';\n document.head.appendChild(style);\n }\n \n // Dark mode CSS - inverts colors but preserves images/video\n style.textContent = '\n /* Invert everything except media */\n html {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #1a1a2e !important;\n }\n \n /* Restore images, videos, iframes, canvas */\n img, video, iframe, canvas, svg, picture, [style*=\"background-image\"] {\n filter: invert(1) hue-rotate(180deg) !important;\n }\n \n /* Preserve specific elements that should not be inverted */\n .no-dark-mode, .no-dark-mode *,\n [data-theme=\"light\"], [data-theme=\"light\"],\n .ace_editor, .ace_editor *,\n .CodeMirror, .CodeMirror *,\n .monaco-editor, .monaco-editor *,\n .markdown-body pre, .markdown-body pre *,\n .highlight, .highlight *,\n pre code, pre code * {\n filter: none !important;\n }\n \n /* Fix common UI elements */\n .modal, .popup, .dropdown-menu, .tooltip, .popover {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #2d2d44 !important;\n border-color: #444 !important;\n }\n \n /* Scrollbars */\n ::-webkit-scrollbar { background: #1a1a2e !important; }\n ::-webkit-scrollbar-thumb { background: #444 !important; }\n ::-webkit-scrollbar-thumb:hover { background: #555 !important; }\n \n /* Selection */\n ::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ';\n }\n \n function removeDarkMode() {\n var style = document.getElementById('universal-dark-mode-style');\n if (style) style.remove();\n }\n \n // Toggle with Alt+Shift+D\n document.addEventListener('keydown', function(e) {\n if (e.altKey && e.shiftKey && e.key === 'D') {\n e.preventDefault();\n enabled = !enabled;\n if (enabled) {\n applyDarkMode();\n console.log('[Universal Dark Mode] Enabled');\n } else {\n removeDarkMode();\n console.log('[Universal Dark Mode] Disabled');\n }\n }\n });\n \n // Apply on load\n applyDarkMode();\n \n // Re-apply on dynamic content\n var observer = new MutationObserver(function(mutations) {\n if (enabled && !document.getElementById('universal-dark-mode-style')) {\n applyDarkMode();\n }\n });\n observer.observe(document.head, { childList: true });\n \n console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');\n})();", "Universal Dark Mode");
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
BranchesTags
Repository files navigation
Halftime | As Seen on CBS | Winner @ xAI Hackathon
HalftimeDemo-720p.mov
AI-powered video advertising that actually works. Instead of interrupting viewers with pre-roll ads, we use AI to find natural moments in videos and seamlessly insert personalized ads that feel like part of the show.
What It Does
Halftime analyzes videos using xAI's Grok Vision to find the perfect moment to show an ad—think natural dialogue breaks, scene transitions, or pauses in conversation. Then it uses AI to insert the ad so smoothly that viewers barely notice the transition.
For Viewers:
  • Watch your favorite shows with ads that don't suck
  • Ads appear at natural moments (not mid-sentence)
  • Personalized based on your interests via X API
  • Seamless playback—no buffering, no interruptions
For Advertisers:
  • Real-time analytics dashboard
  • Context-aware ad placement (right audience, right moment)
  • Performance metrics: CTR, engagement, conversions
  • Campaign management tools
How It Works
  1. AI Analysis: Grok Vision analyzes the video transcript + frames to find high-attention moments
  2. Smart Placement: AI scores candidate moments based on context, user interests, and visual flow
  3. Seamless Insertion: Hardware-accelerated video processing inserts ads without re-encoding the entire video
  4. Real-Time Streaming: HLS streaming with dynamic playlist updates—viewers can start watching immediately
Tech Stack
Frontend:
  • Next.js 16 + React 19 + TypeScript
  • Custom HLS video player with real-time ad markers
  • Tailwind CSS for responsive design
  • Recharts for analytics visualization
Backend:
  • Python 3.13 + FastAPI for high-performance API
  • FFmpeg hardware acceleration (VideoToolbox)
  • Supabase for auth + database
  • Real-time HLS streaming
AI & APIs:
  • xAI Grok Vision (video + transcript analysis)
  • WaveSpeed AI (video generation)
  • X API (audience personalization)
  • OMDb (movie metadata)
Key Features
  • Two-Stage AI Analysis: Transcript parsing + visual verification for optimal placement
  • Hardware Acceleration: 3-5 minute processing for 43-minute videos
  • Dual Frontends: Viewer platform + advertiser dashboard
  • Real-Time Analytics: Track impressions, clicks, conversions, engagement
  • Personalized Targeting: Uses X API signals for context-aware ads
  • Zero-Wait Streaming: Watch while processing happens in background
Performance
  • Processes 43-minute videos in 3-5 minutes with hardware acceleration
  • Dynamic HLS playlist updates for seamless viewing
  • Real-time ad tracking and analytics
  • Multi-tenant architecture supporting multiple advertisers
Architecture
┌─────────────────────────────────────────────────┐
│ Viewer App (Next.js) | Dashboard (Next.js) │
│ - Video Player | - Analytics │
│ - Ad Tracking | - Campaigns │
└──────────────────┬──────────────────────────────┘
│
┌─────────▼─────────┐
│ FastAPI Backend │
│ - Auth │
│ - Video Jobs │
│ - HLS Streaming │
└─────────┬─────────┘
│
┌──────────────┼──────────────┐
│ │ │
┌───▼───┐ ┌─────▼─────┐ ┌───▼────┐
│ Grok │ │ WaveSpeed │ │ X │
│ Vision│ │ AI (Wan2) │ │ API │
└───────┘ └───────────┘ └────────┘

Getting Started
Prerequisites
  • Node.js 18+
  • Python 3.13+
  • FFmpeg installed
Environment Setup
# Required API keys
XAI_API_KEY=your_grok_api_key
WAVESPEED_API_KEY=your_wavespeed_key
X_BEARER_TOKEN=your_x_api_token
SUPABASE_URL=your_supabase_url
SUPABASE_SERVICE_KEY=your_supabase_key
Run Viewer Platform
cd frontend/xvideos
npm install
npm run dev
Run Dashboard
cd frontend/dashboard
npm install
npm run dev
Run Backend API
cd backend/dashboard
pip install -r requirements.txt
uvicorn app.main:app --reload
Why Halftime?
Traditional video ads are broken:
  • ❌ Pre-roll ads annoy viewers before content even starts
  • ❌ Mid-roll ads interrupt at random, jarring moments
  • ❌ Static ads ignore viewer preferences and context
  • ❌ Poor targeting leads to wasted ad spend
Halftime fixes this:
  • ✅ AI finds natural moments that don't disrupt flow
  • ✅ Visual verification ensures placements make sense
  • ✅ Personalized targeting based on user interests
  • ✅ Real-time analytics for advertisers
  • ✅ Seamless viewing experience for audiences
Built with ❤️ using xAI Grok Vision, Next.js, Python, and a lot of FFmpeg magic.
About
No description, website, or topics provided.
Resources
Readme
Activity
Custom properties
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages