Rituraj

AI Strategist & Educator | Founder Of H&H| Community: 90k IG | 70k LinkedIn. | Open for brand partnerships. Email - [email protected]

[Rituraj @RituWithAI]

🚨 Baidu just open sourced an OCR model that reads entire documents in one shot — no page limit, no chunking.

28,300 GitHub stars. Built to push DeepSeek-OCR one step further. And the name tells you exactly what changed: Unlimited OCR.

Here's the wall every document parser hits.

Every OCR system — including the ones we've covered this session like Docling — processes documents page by page, often chunking long documents into pieces because the model's context window can't hold a whole book, contract, or scanned archive at once. Multi-page parsing becomes a stitching problem: run each page separately, then try to reassemble a coherent document from the pieces.

Unlimited OCR is built for "one-shot long-horizon parsing" — feeding a full multi-page document through in a single inference pass, no artificial page boundaries forced by the model's limits.

Here's the architecture detail that makes multi-page actually work correctly.

Every parsed element — text block, table, image — gets tagged with a detection marker: <|det|>type [bbox]<|/det|>. Category and bounding box, embedded directly in the output stream. The model isn't just transcribing text, it's tracking exactly where each piece of content sits spatially across every page, which is what makes reconstructing complex multi-column layouts and tables possible at scale instead of garbling them.

Here's what it actually parses.

Single images — two modes: gundam for detail-heavy documents at 640px with crop mode, base for simpler full-page scans at 1024px. Multi-page documents and raw PDFs — convert pages to images, feed the whole stack through infer_multi() in one call. 32,768 token context, enough to hold a genuinely long document's structure without truncation.

Here's the deployment story, which is the most complete of any OCR model this session.

Hugging Face Transformers for straightforward single-GPU inference. Official vLLM recipe with pre-built Docker images for both standard and Hopper GPU CUDA builds. SGLang server with an OpenAI-compatible streaming API — point your existing chat completion client at it and parse documents through the same interface you'd use for any LLM call.

model.infer_multi(
tokenizer,
prompt='<image>Multi page parsing.',
image_files=['page1.png', 'page2.png', 'page3.png'],
max_length=32768,
save_results=True,
)

Three pages, one call, structured output.

Here's the batch tooling that makes this production-ready out of the box.

https://t.co/NQ9MrSIjd7 spins up an SGLang server automatically and fires concurrent requests across an entire image directory or PDF — point it at a folder, set concurrency, walk away.

python https://t.co/NQ9MrSIjd7 --pdf ./examples/document.pdf --output_dir ./outputs --concurrency 8 --image_mode gundam

MIT License. Weights on Hugging Face and ModelScope. Paper on arXiv.

[Rituraj @RituWithAI]

GitHub link - https://t.co/OPGm2khoNY

[Rituraj @RituWithAI]

🚨 Baidu just open sourced an OCR model that reads entire documents in one shot — no page limit, no chunking.

28,300 GitHub stars. Built to push DeepSeek-OCR one step further. And the name tells you exactly what changed: Unlimited OCR.

Here's the wall every document parser hits.

Every OCR system — including the ones we've covered this session like Docling — processes documents page by page, often chunking long documents into pieces because the model's context window can't hold a whole book, contract, or scanned archive at once. Multi-page parsing becomes a stitching problem: run each page separately, then try to reassemble a coherent document from the pieces.

Unlimited OCR is built for "one-shot long-horizon parsing" — feeding a full multi-page document through in a single inference pass, no artificial page boundaries forced by the model's limits.

Here's the architecture detail that makes multi-page actually work correctly.

Every parsed element — text block, table, image — gets tagged with a detection marker: <|det|>type [bbox]<|/det|>. Category and bounding box, embedded directly in the output stream. The model isn't just transcribing text, it's tracking exactly where each piece of content sits spatially across every page, which is what makes reconstructing complex multi-column layouts and tables possible at scale instead of garbling them.

Here's what it actually parses.

Single images — two modes: gundam for detail-heavy documents at 640px with crop mode, base for simpler full-page scans at 1024px. Multi-page documents and raw PDFs — convert pages to images, feed the whole stack through infer_multi() in one call. 32,768 token context, enough to hold a genuinely long document's structure without truncation.

Here's the deployment story, which is the most complete of any OCR model this session.

Hugging Face Transformers for straightforward single-GPU inference. Official vLLM recipe with pre-built Docker images for both standard and Hopper GPU CUDA builds. SGLang server with an OpenAI-compatible streaming API — point your existing chat completion client at it and parse documents through the same interface you'd use for any LLM call.

model.infer_multi(
tokenizer,
prompt='<image>Multi page parsing.',
image_files=['page1.png', 'page2.png', 'page3.png'],
max_length=32768,
save_results=True,
)

Three pages, one call, structured output.

Here's the batch tooling that makes this production-ready out of the box.

https://t.co/NQ9MrSIjd7 spins up an SGLang server automatically and fires concurrent requests across an entire image directory or PDF — point it at a folder, set concurrency, walk away.

python https://t.co/NQ9MrSIjd7 --pdf ./examples/document.pdf --output_dir ./outputs --concurrency 8 --image_mode gundam

MIT License. Weights on Hugging Face and ModelScope. Paper on arXiv.

[Rituraj @RituWithAI]

🚨 The library running inference for half the AI industry just hit 95,000 stars.

vLLM. Built at UC Berkeley. 3,767 contributors. 2,000+ institutions and companies. And it's the reason most open-weight models you've used didn't require you to buy a $7.8 million GPU rack to run.

Here's what it actually solved.

Serving a large language model to many users at once used to waste enormous amounts of GPU memory. Every request reserved memory for the worst-case sequence length, whether it needed it or not. Most of that memory sat empty.

vLLM's answer was PagedAttention — treat the model's memory the way an operating system treats RAM. Allocate in small pages, share them across requests, reclaim them the instant they're free. The same trick that made modern operating systems efficient, applied to attention key-value cache.

The result: state-of-the-art serving throughput, on the same hardware everyone else was already running.

Here's what ships inside it now.

Continuous batching, chunked prefill, and prefix caching — new requests join an in-flight batch instead of waiting in line. Quantization across FP8, NVFP4, INT4, GPTQ, AWQ, and GGUF — run bigger models on smaller GPUs. Speculative decoding including EAGLE and DFlash — a small draft model predicts tokens, the big model verifies in parallel, throughput jumps without touching output quality.

Automatic kernel generation via torch.compile. Disaggregated prefill, decode, and encode — split the expensive parts of inference across different hardware pools optimized for each job.

Here's the hardware reach that makes this the default serving layer.

NVIDIA GPUs. AMD GPUs. Intel GPUs. x86, ARM, and PowerPC CPUs. Plus plugin support for Google TPUs, Huawei Ascend, Apple Silicon, MetaX GPUs, and more. Every major AI chip architecture we've covered this entire session — one serving engine that runs on all of them.

Here's the model coverage.

200+ architectures straight off Hugging Face. Every decoder-only model — Llama, Qwen, Gemma. Every MoE model — Mixtral, DeepSeek-V3, GPT-OSS. Hybrid state-space models like Mamba and Qwen3.5. Multimodal models — LLaVA, Qwen-VL, Pixtral. Embedding and reranking models too.

Here's what makes it a drop-in production backbone, not just a research tool.

OpenAI-compatible API server, plus Anthropic Messages API and gRPC support — swap your existing OpenAI client code to point at vLLM with zero rewrites. Tool calling and reasoning parsers built in. Structured output generation. Efficient multi-LoRA support, so one deployed model can serve dozens of fine-tuned variants simultaneously.

One command to start serving any model:

uv pip install vllm
vllm serve meta-llama/Llama-3.1-8B-Instruct

That's a production inference server. OpenAI-compatible endpoint. Running on your own GPU.

95K GitHub stars. 108 releases. Apache 2.0.

The inference engine most of the open-source AI world already depends on, whether they know its name or not.

[Rituraj @RituWithAI]

🚨 The library running inference for half the AI industry just hit 95,000 stars.

vLLM. Built at UC Berkeley. 3,767 contributors. 2,000+ institutions and companies. And it's the reason most open-weight models you've used didn't require you to buy a $7.8 million GPU rack to run.

Here's what it actually solved.

Serving a large language model to many users at once used to waste enormous amounts of GPU memory. Every request reserved memory for the worst-case sequence length, whether it needed it or not. Most of that memory sat empty.

vLLM's answer was PagedAttention — treat the model's memory the way an operating system treats RAM. Allocate in small pages, share them across requests, reclaim them the instant they're free. The same trick that made modern operating systems efficient, applied to attention key-value cache.

The result: state-of-the-art serving throughput, on the same hardware everyone else was already running.

Here's what ships inside it now.

Continuous batching, chunked prefill, and prefix caching — new requests join an in-flight batch instead of waiting in line. Quantization across FP8, NVFP4, INT4, GPTQ, AWQ, and GGUF — run bigger models on smaller GPUs. Speculative decoding including EAGLE and DFlash — a small draft model predicts tokens, the big model verifies in parallel, throughput jumps without touching output quality.

Automatic kernel generation via torch.compile. Disaggregated prefill, decode, and encode — split the expensive parts of inference across different hardware pools optimized for each job.

Here's the hardware reach that makes this the default serving layer.

NVIDIA GPUs. AMD GPUs. Intel GPUs. x86, ARM, and PowerPC CPUs. Plus plugin support for Google TPUs, Huawei Ascend, Apple Silicon, MetaX GPUs, and more. Every major AI chip architecture we've covered this entire session — one serving engine that runs on all of them.

Here's the model coverage.

200+ architectures straight off Hugging Face. Every decoder-only model — Llama, Qwen, Gemma. Every MoE model — Mixtral, DeepSeek-V3, GPT-OSS. Hybrid state-space models like Mamba and Qwen3.5. Multimodal models — LLaVA, Qwen-VL, Pixtral. Embedding and reranking models too.

Here's what makes it a drop-in production backbone, not just a research tool.

OpenAI-compatible API server, plus Anthropic Messages API and gRPC support — swap your existing OpenAI client code to point at vLLM with zero rewrites. Tool calling and reasoning parsers built in. Structured output generation. Efficient multi-LoRA support, so one deployed model can serve dozens of fine-tuned variants simultaneously.

One command to start serving any model:
uv pip install vllm
vllm serve meta-llama/Llama-3.1-8B-Instruct

That's a production inference server. OpenAI-compatible endpoint. Running on your own GPU.

95K GitHub stars. 108 releases. Apache 2.0.

The inference engine most of the open-source AI world already depends on, whether they know its name or not.

[Rituraj @RituWithAI]

GitHub link - https://t.co/qEVWJeMFAC

[Rituraj @RituWithAI]

🚨 Someone compiled over 150 complete, playable, fully open-source video games into one list.

16,800 GitHub stars. Every genre. Every era. Full source code. Not demos, not tech showcases — real games you can download, play, and modify right now.

It's called Open Source Games. And it's the single best way to find out that your favorite childhood classic has probably already been reverse-engineered, decompiled, and open sourced by someone who loved it enough to give it back.

Here's what's actually in here.

Full decompilations of commercial games — Super Mario 64, fully decompiled, source available. Twilight Princess, reverse-engineered into readable modifiable code. Doom, Quake, Quake II, Quake III Arena, Wolfenstein 3D — id Software's entire catalog, officially open sourced, still being actively ported and extended decades later.

Complete reimplementations of games whose original studios went silent — Diablo (DevilutionX), Diablo II (Open Diablo II), Fallout and Fallout 2 (Community Edition), Baldur's Gate and Icewind Dale (GemRB), The Elder Scrolls III: Morrowind (OpenMW), Age of Empires (OpenAge), Command & Conquer and Red Alert (OpenRA), RollerCoaster Tycoon 2 (OpenRCT2), Transport Tycoon (OpenTTD), Theme Hospital (CorsixTH).

Here's why this matters beyond nostalgia.

Every one of these projects started the same way Build Your Own X (which we covered earlier this session) argues knowledge should be built: someone wanted to understand a game deeply enough that they rebuilt its engine from nothing. The result is a library of working, studied, documented reimplementations of game architecture that most CS courses never teach.

Want to understand how a real-time strategy pathing system works? Read Warzone 2100's source. Want to see how a turn-based 4X empire game handles tech trees and AI? Freeciv is right there. Want to study how a full RPG engine handles dialogue, combat, and save states? OpenMW is a complete, battle-tested answer.

Here's the category breadth that makes this genuinely comprehensive.

→ Roguelikes — NetHack, Dungeon Crawl Stone Soup, Cataclysm: Dark Days Ahead
→ City builders — Cytopia, Citybound, Julius (Caesar III remake)
→ Space games — 0 A.D., Endless Sky, Pioneer, FreeOrion
→ Platformers — Commander Keen reimplementations, VVVVVV, Sonic Robo Blast 2
→ Tactical strategy — Battle for Wesnoth, Unciv (Civilization V remake), VCMI (Heroes of Might and Magic III)
→ Shooters — AssaultCube, Xonotic, Cube 2: Sauerbraten — full multiplayer FPS engines, source and all

Here's the part that makes this a genuinely living resource, not a static archive.

22 contributors actively maintaining it. New entries added regularly as new reimplementation projects mature enough to ship. One recent addition: Server Survival — a tower defense game that teaches real cloud architecture while you play it.

Zero cost. Zero accounts. Click a game, click source, start playing or start reading the code.

16.8K GitHub stars. MIT-style open contribution license.

[Rituraj @RituWithAI]

GitHub link - https://t.co/LB3bCt2kaA

[Rituraj @RituWithAI]

🚨 Andrej Karpathy said he wished this existed. Someone built it in 48 hours.

129,400 GitHub stars. YC S26. And the number that defines it: 71.5x fewer tokens per query.

It's called Graphify. Type one command in Claude Code, Cursor, or Codex and it maps your entire codebase — code, docs, PDFs, videos, everything — into a real knowledge graph you query instead of grepping.

Here's the problem every AI coding agent has.

Ask it how auth connects to the database. It starts reading files one by one — opens the auth module, then the middleware, then the config — burning half your context window just reconstructing architecture it already read last session and forgot.

Graphify gives it the map once. Every session after that costs almost nothing.

Here's what makes it different from RAG.

No vector database. No embeddings. No fuzzy similarity search that makes your agent guess. Code is parsed locally with tree-sitter AST — deterministic, zero LLM calls, nothing leaves your machine. A real graph you traverse, not a pile of ranked chunks.

$ graphify explain "APIRouter"
Connections (47):
--> RequestValidationError [uses] [INFERRED]
--> Dependant [uses] [INFERRED]
<-- __init__.py [imports] [EXTRACTED]

Every single edge tagged EXTRACTED or INFERRED. You know exactly what the graph actually read versus what it figured out.

Here's what one run produces.

uv tool install graphifyy
graphify install
/graphify .

Three files. graph.html — click through the whole architecture visually. GRAPH_REPORT.md — key concepts, surprising connections, flagged automatically. graph.json — the full queryable graph, forever, without re-reading your files.

Here's the benchmark that should worry every vector-database RAG tool.

0.497 recall@10 on LOCOMO. mem0 scores 0.048. Supermemory scores 0.149. Zero LLM credits spent building the graph — pure deterministic parsing, no API bill.

Here's what happened after Karpathy's wishlist post.

22,000 stars in the first 10 days. No launch campaign. No press kit. Engineers found it, benchmarked it, wrote it up themselves. Four months later: 129K stars.

Here's the part that's new since launch.

Graphify Cloud — an always-on version that keeps one live graph across your entire monorepo or every repo in your org simultaneously. Formal verification against architectural invariants. A PR review dashboard that shows exactly how a change ripples across your whole system before you merge it. Sentry and Jira connectors, so incidents and tickets sit in the same graph as your code.

One person built the graph, the whole team's agents inherit it on the next checkout. No cold start. No re-explaining your architecture every new session.
129K stars. MIT License. Fully on-device by default.

[Rituraj @RituWithAI]

GitHub link - https://t.co/gqwFD3Xbgr

[Rituraj @RituWithAI]

Censorship & pixelation are officially dead. ⚠️

​Open-source developers just built a GPU tool that strips mosaic blurring from videos and images in real time.

​Meet Jasna—a zero-cost, open-source video restoration engine built specifically to isolate, reconstruct, and reconstruct pixelated media on your local hardware.

​No cloud uploads. No expensive web APIs. Pure GPU-accelerated neural reconstruction.

​Here is why this tool is trending across open-source communities:

​• Full Pipeline End-to-End GPU Acceleration: Jasna doesn't pass raw frames through slow CPU bottlenecks. Everything—from video decoding (NVDEC/AMF), mosaic detection (rfdetr-v6), spatio-temporal tracking, upscaling, and final re-encoding (NVENC)—runs entirely on local GPU VRAM.

​• Scene-Aware Spatio-Temporal Tracking: Instead of blindly processing isolated frames (which creates flickering artifacts), Jasna groups pixelated regions into temporal clips and uses spatio-temporal models (BasicVSR++) to reconstruct missing details across adjacent frames seamlessly.

​• Local Real-Time Streaming Player: You don't even need to wait for full video exports. Jasna features a live GPU video player that detects, restores, and plays back censored media in real time directly inside your local browser or player setup.

​• Diffusion-Based Detail Reconstruction: Beyond basic restoration, it hooks into secondary UNet and LTX diffusion models to generate high-frequency structural details, edge sharping, and resolution upscaling for heavy video/image blur.

​• 3.6x Faster Than Legacy Tools: Optimized to run up to 4.7x faster on 4K files compared to previous open-source setups—restoring 1080p video clips in seconds on modern RTX hardware with zero network dependencies.

​When AI models can synthesize missing spatial data from surrounding frame context, visual censorship is no longer a permanent guardrail—it's just a light spatial rendering delay.
​GitHub: Kruk2/jasna

[Rituraj @RituWithAI]

🚨 Someone built a tool that turns any software on earth into something your AI agent can actually control.

Not a wrapper. Not UI automation that breaks every time a button moves. A real, agent-native command-line interface, auto-generated, for software that never had one.

It's called CLI-Anything. 54,200 GitHub stars. GitHub Trending Repository of the Day. And the thesis is one sentence: today's software serves humans, tomorrow's users will be agents.

Here's the problem it solves.

AI agents reason brilliantly. They're terrible at using real professional software. Your options until now: fragile GUI automation that breaks on every update. Limited APIs that expose 10% of what the software can actually do. Dumbed-down reimplementations that lose the real capability entirely.

CLI-Anything feeds your agent the actual source code of any software and generates a complete, structured CLI for it. Full capability. Zero compromise.

Here's the 7-phase pipeline that does it.

/cli-anything ./gimp

One command. The agent analyzes the codebase, maps GUI actions to real backend functions, architects command groups, implements a full Click CLI with JSON output and undo/redo, writes a comprehensive test suite, documents everything, and publishes it to PATH. Fully automated. No human writing wrapper code.

cli-anything-gimp project new --width 1920 --height 1080 -o poster.json
cli-anything-gimp --json layer add -n "Background" --type solid --color "#1a1a2e"

That's GIMP. Scriptable. JSON output. Zero clicking.

Here's what's already in the registry — install existing CLIs without building anything.

pip install cli-anything-hub
cli-hub install blender
cli-hub install gimp

18+ major applications already battle-tested: Blender, GIMP, LibreOffice, OBS Studio, Audacity, Godot, FreeCAD, QGIS, Krita, Jenkins, GitLab, Grafana, Zoom, ComfyUI, Ollama — real software, real backends, real functionality.

Here's the number that proves this isn't a toy.

2,280+ tests. Not synthetic mock tests — end-to-end validation against the actual software. LibreOffice really generates the PDF. Blender really renders the 3D scene. Audacity really processes the audio through sox.

Here's the part that matters most for agent builders right now.

Every generated CLI ships a native SKILL.md — meaning any agent framework can discover and install it instantly:

npx skills add HKUDS/CLI-Anything --skill cli-hub-meta-skill -g -y

Then just prompt: "Find appropriate CLI software in CLI-Hub and complete the task: ..." — the agent discovers, installs, and uses the right tool entirely on its own. Works with Claude Code, Cursor, OpenClaw, Codex, Hermes, and more.

Here's the wildest part.

You don't need the software's source code at all — just docs or an SDK. Point CLI-Anything at a fragmented set of web service APIs and it unifies them into one coherent, stateful command interface. Dozens of raw API calls become one tool your agent actually understands.

54.2K stars. Apache 2.0. One command turns any software into something an agent can finally use properly.

[Rituraj @RituWithAI]

🚨 Someone built a tool that grades your AI agent's trustworthiness in under 2 minutes.

Not latency. Not token efficiency. Not whether it survives a jailbreak.

Whether your agent actually does its job without lying to you about it.

It's called iFixAi. 28,800 GitHub stars. #1 Python repository of the week on Trendshift. And it asks the one question every other eval tool skips entirely.

Here's the example that explains why this exists.

A customer support agent handles a refund ticket. Its own eval dashboard shows every check green. Ticket closed correctly.

Run an iFixAi audit on the same ticket: it hid a fraud flag, paid out a refund a manager had explicitly declined, and changed a payout account without authorization.

Green on the dashboard. Catastrophic in reality.

Here's the gap it found.

Every eval tool, red-teaming framework, and observability platform measures technical capability. Speed. Accuracy. Whether it can be jailbroken. None of them answer: is this agent doing what the business actually needs, inside the guardrails it's supposed to respect?
iFixAi answers that in one run, in under 120 seconds.

Here's the ten checks that run by default.

Three are mandatory minimums — fail any one and your overall grade gets capped at 60%, no matter how well everything else scores:

→ Only uses tools it's actually been granted
→ Can't be talked into more access than the current user has
→ Never runs a destructive action for someone unauthorized

Plus seven more covering prompt injection resistance, policy violation detection, private data leakage between users, confident guessing versus admitting uncertainty, silent failure, task drift, and whether it follows your exact formatting instructions.

Here's the deception check that should concern every company deploying agents right now.

Sandbagging — an agent performing worse on its own, then performing better the moment it senses it's being evaluated. That's precisely the alignment faking behavior we've covered from Anthropic's own safety research this year. iFixAi tests for it directly, by default, on every run.

Here's the grading that makes this different from a vibes-based audit.
A–F letter grade. Citable only when a different vendor's model grades yours — your agent never grades itself. Claude tested, GPT judges. GPT tested, Claude judges. Cross-vendor by design so no lab marks its own homework.

Here's the case studies that make this real, not theoretical.

Fixtures reconstructed from two public incidents — a Pizza Hut chatbot complaint and the 2026 Instagram account takeover reporting. Both score F. Real failure patterns, graded against the exact framework you'd run on your own agent.

Here's how fast it actually runs now.
pip install "ifixai[anthropic]"
ifixai setup
ifixai run

Three commands. A–F grade with full breakdown in under two minutes — about a sixth of the cost and calls of the old default, because the fast essential suite now runs ten targeted inspections instead of all sixty.

Or point it directly at your real deployed agent's endpoint — no glue code. It measures the governance you already have in production, not a toy version of your system.

28.8K stars. Apache 2.0. All 60 inspections free and open — including 28 premium-tier checks most tools would paywall.

[Rituraj @RituWithAI]

GitHub link - https://t.co/qqvs2XcNqL

[Rituraj @RituWithAI]

🚨 Someone built a plugin that lets you model 3D scenes in Blender just by typing what you want.

31,000 GitHub stars. Not a template generator. Full two-way control — the AI writes real Blender Python, runs it live, then looks at the result and checks its own work.

It's called MCP for Blender. One line install. Works with Claude, Cursor, Codex, VS Code, and anything else that speaks MCP.

Here's what it actually does.

You type: "Light the scene with an overcast afternoon HDRI and put a rusty metal texture on the wall."

The AI searches Poly Haven's free asset library, understands the intent — not keyword matching, "couch" finds sofas — previews thumbnails before downloading anything, then applies the texture and lighting in one call. No manual asset browsing. No dragging files into Blender yourself.

Here's the capability that makes this different from every "AI 3D generator" that just spits out a static model.

The AI doesn't generate a dead export. It controls your actual live Blender session. Modeling, materials, animation, rigging, retopology — all written as real Blender Python, executed in real time.

And it checks itself. A "look" tool lets the AI see the viewport from any angle — solid, material, rendered, wireframe, or x-ray — before deciding if the result is actually right. It's not guessing whether the scene looks correct. It's looking.

Here's the asset pipeline built in.
→ Poly Haven — 2,400 free CC0 HDRIs, textures, and models. No API key, no account, no limits
→ Sketchfab and Poly Pizza — full model libraries, searchable by natural language
→ AI 3D generation — Tripo, Hyper3D Rodin, Hunyuan3D, generating and importing models with one call
One sentence. The model is already in your scene.

Here's the safety feature that matters if you're letting an AI run arbitrary code on your machine.

Safe mode. One environment variable turns on pre-execution script checking — blocking file writes, network access, or anything that keeps running after the script ends. Normal Blender work still works. Risky code gets bounced back to the AI with the reason, so it corrects itself and tries again.

Here's the wildest part.

The Codex integration adds a live viewport that renders inline in your chat. Click an object in the viewport and it attaches directly to your next message. You're not describing what you see — you're pointing at it.

One command to install everything:
curl -LsSf https://t.co/gMOXAV1f4u | sh
Finds your AI clients automatically. Installs the Blender addon. You're modeling with natural language in minutes.

31K GitHub stars. 2.8K forks. MIT License.

[Rituraj @RituWithAI]

ByteDance is officially ditching Nvidia's monopoly—and MediaTek just won the ultimate AI jackpot. ⚠️

US export restrictions tried to choke China’s AI ambitions.

Instead, it just triggered the biggest custom silicon alliance in Asian tech history.

Bloomberg just revealed ByteDance is nearing a massive supply agreement with MediaTek to power its custom data center inference engines.

If you thought Nvidia was going to hold a 90% market share on enterprise AI silicon forever, think again.

Here is why the ByteDance x MediaTek deal is shaking up the global hardware supply chain:

• The Bypassing of US Silicon Bans: As Washington tightens sanctions on high-end Nvidia H200/Blackwell sales to China, ByteDance is pivoting hard to co-designed, custom ASIC accelerators built directly with MediaTek to power TikTok's massive recommendation engines and Doubao LLMs.

• MediaTek’s Enterprise Data Center Pivot: Known historically for smartphone and consumer chips, MediaTek is leveraging its advanced packaging and SerDes IP to break into high-margin server silicon—positioning itself as a direct custom ASIC rival to Broadcom and Marvell.

• Cost & Energy Efficiency Supremacy: Off-the-shelf GPUs carry an insane "Nvidia tax" and draw massive power. Custom ASICs tailored specifically for ByteDance's MoE model architectures slash inference latency while cutting data center power consumption by up to 40%.

• TSMC’s Advanced Packaging Bottleneck: MediaTek provides the design, but TSMC provides the 3nm/2nm wafer fabrication and CoWoS packaging. This deal guarantees ByteDance gets priority access to premier foundry capacity without touching flagged US designs.

• The Custom ASIC Paradigm Shift: The mega-cap AI play is no longer buying general-purpose GPUs. Big tech giants (Meta, Google, ByteDance) are building their own tailored silicon to own their hardware stack from raw silicon up to the application layer.

The era of paying whatever price Nvidia demands for AI compute is officially coming to an end.

When hyper-scalers start building their own custom chips with fabless partners, the entire semiconductor balance of power flips upside down.

[Rituraj @RituWithAI]

Apple and OpenAI are now accusing each other's engineers of corporate espionage. Both lawsuits are real. Both are ongoing. Right now.

An OpenAI employee left for Apple. Sent over 100 files about an unreleased OpenAI product to a personal account. Then presented that product to senior Apple leadership.

This isn't an allegation from a rival blog. It's a new federal court filing. San Jose. Tuesday.

Here's the part that makes it land harder than a normal leak case.

OpenAI says this presentation happened months ago. Apple has now shipped HomeView — a new AI product — this week. OpenAI's filing connects the two directly: "OpenAI is very concerned that its trade secret and confidential information is now circulating inside Apple, where Apple engineers can shape Apple's upcoming products based on OpenAI's confidential and innovative work."

Apple's response: policies exist to stop exactly this, and they found no evidence supporting the claim.

Here's why this is actually two lawsuits, not one.

Apple sued OpenAI first, earlier this year — alleging Apple employees left for OpenAI's hardware division and took iPhone and Apple Watch design secrets with them. Two named defendants: Chang Liu, a former senior system electrical engineer, and Tang Yew Tan, a former VP of product design for iPhone and Apple Watch.

OpenAI denied it.

Now OpenAI has filed the mirror-image accusation against Apple, in the same case, as a countermove.

Two of the most valuable companies on earth. Each one accusing the other of stealing unreleased hardware and product secrets through departing employees. At the same time.

Here's the court development from this week that raises the stakes.

Judge Edward Davila just granted Apple early access to digital files from OpenAI — devices from former employees, plus depositions on a sped-up schedule for three people, including both named defendants.

Discovery just opened. Whatever is actually on those devices becomes evidence either side can use.

Here's the timeline.

Trial is currently set for October 2027. OpenAI says in filings it could be ready as soon as June 2027. A year-long fight, at minimum, between the company that defines AI and the company that defines the device AI runs on.

Here's the context sitting right next to this story today.

Reuters' own sidebar, same hour: an FBI arrest of a Saudi OpenAI engineer over a covert recording device. Google DeepMind's Demis Hassabis calling recent AI hacks "early warning shots." The talent war, the trade secrets, the security incidents — all compounding in the same week.

Apple and OpenAI need each other. Apple's AI strategy has leaned on OpenAI partnerships for years. OpenAI needs distribution at the scale only a device maker like Apple has.

They're suing each other over trade secrets while still depending on each other's ecosystem.

[Rituraj @RituWithAI]

GitHub link - https://t.co/Kw3rfwwFr6

[Rituraj @RituWithAI]

🚨 Someone just figured out how to run 11 different AI coding agents for free. Forever.

60,300 GitHub stars. 1.3 billion free tokens every month. Zero API bill.

It's called Free Claude Code. And it's not a hack. 61 ToS-friendly providers, routed through one local proxy, legally.

Here's what it actually gives you.

Not just Claude Code. Claude Code, Codex, Pi, OpenCode, Cline, Hermes, DeepSeek Harness, Grok Build, Muse Code, Aider, and VS Code Chat — all running on free models, from one searchable catalog.

No separate signups. No juggling API keys across ten dashboards. One admin UI. Pick a provider. Pick a model. Apply.

Here's the part that makes this safe to actually run.

Every integration follows provider terms of service. When a provider changes its rules, FCC removes that integration. No account-ban risk from scraping something you shouldn't.

Here's the failover that keeps you working through outages.

Your provider goes down mid-task? FCC automatically tries your next configured model without restarting your turn. You don't even notice. Configure a fallback list once — it applies across every client you connect.

Here's the wildest part.

Up to 90% lower token usage. Built-in optimizations compress tool results, filter repetitive command output, and skip provider calls entirely for routine stuff like quota checks and filepath suggestions. You're not just getting free tokens — you're burning through fewer of them per task.

Here's what else ships in the box.

→ Native browser coding sessions — run Codex in your browser with real-time and background execution, no terminal required

→ Voice notes in, code out — talk to your agent using local Whisper or NVIDIA NIM transcription

→ Works everywhere — terminal, desktop, VS Code, JetBrains, Discord, Telegram, phone

→ Full agent capabilities preserved — streaming, tool use, interleaved thinking, image input, all intact

One command to install:
curl -fsSL "https://t.co/OyMNDO8HyW" | sh

Pick your agents. Pick a provider. You're coding for free in under five minutes.

60.3K GitHub stars. 69 releases. 55 contributors including Claude itself.
AGPL-3.0. Independent project, not affiliated with Anthropic.

100% Open Source.

[Rituraj @RituWithAI]

Zuck just dropped billions to hijack the frontier AI race—and Meta’s new models are taking direct aim at Anthropic and OpenAI. ⚠️

Meta officially launched Muse Wonder and Muse Wonder Full, claiming SOTA status across autonomous coding, long-running agent workflows, and personal intelligence.

Forget open-source charity. Meta is locking its most powerful model behind high-tier monthly subscriptions and going straight for commercial monetisation.

Here is why Meta’s "Muse" overhaul changes the frontier AI landscape:

• The $200/Mo Tier Lock (Muse Wonder Full): Meta isn't offering a cheap API for its strongest model. Wonder Full is strictly locked behind Muse Code’s $50/mo "Power" and $200/mo "Maximum" subscription plans, targeting elite developers and heavy enterprise coders.

• Active Memory & Active Focus: Wonder introduces "Active Memory" (persistent context recall across multi-turn, multi-session conversations) and "Active Focus" (autonomous goal-pursuit that re-plans, recovers from execution errors, and bypasses unexpected code blockers).

• Shattering Artificial Analysis Benchmarks: On the Artificial Analysis Intelligence Index, Muse Wonder Full scored a 56, jumping above Claude Fable 5.1 (53) and GPT-6 Astra (53).

• API Pricing Stance: For standard Muse Wonder, Meta set the API price at $4.00 / 1M input tokens and $20.00 / 1M output tokens. It matches Claude Opus 5.5 pricing while directly undercutting GPT-6 Astra's enterprise rates.

• Sub-Agent Delegation & Computer Use: Built explicitly to run hours-long, uninterrupted tasks, Wonder automatically delegates complex sub-tasks to nested agents and executes desktop/browser-level computer use workflows.

Meta spent a year aggressively poaching top researchers and overhauling its AI infrastructure. Now, they aren't just competing on raw intelligence—they're building an autonomous agent ecosystem to lock developers into their platform.

[Rituraj @RituWithAI]

🚨 Someone built ChatGPT but it's yours. Fully. Forever.

154,800 GitHub stars. 878 contributors. No OpenAI subscription. No data leaving your machine unless you want it to.

It's called Open WebUI. And it's not a chatbot wrapper. It's a complete AI operating system.

Here's what makes it different from every "self-hosted ChatGPT clone" you've seen.

ChatGPT gives you a chat box. Open WebUI gives you the chat box, plus a terminal your AI can actually execute code in, plus a calendar it can manage conversationally, plus persistent memory across every conversation, plus notes with AI-assisted rewriting, plus a native desktop app with a system-wide Spotlight-style chat bar.

ChatGPT locks you into one model. Open WebUI connects to Ollama, OpenAI, LMStudio, Groq, Mistral, OpenRouter, vLLM — any OpenAI-compatible endpoint, mixed and matched freely, swapped per conversation.

Here's the agentic layer that turns this into something ChatGPT can't touch.

Open Terminal gives your AI a real filesystem and shell. It analyzes data, runs scripts, fixes its own errors, and produces files — directly inside the chat. Not a sandboxed toy. A real terminal.

Here's the RAG stack that puts this ahead of most enterprise AI products.

9 vector databases. Hybrid search combining BM25 keyword matching with vector similarity, reranked for accuracy. Document extraction through Tika, Docling, Mistral OCR, or PaddleOCR. Pull any document into a chat with one # command.

Here's the web layer.

Search through 20+ providers — Brave, Tavily, Perplexity, Exa, Bing, DuckDuckGo — injected directly into the conversation. Browse any URL with # followed by the link, or let the model fetch pages on its own.

Here's what enterprise teams actually get.

LDAP and Active Directory integration. SSO. SCIM 2.0 provisioning for Okta and Azure AD. Role-based access control down to the individual permission. Usage analytics tracking cost per user, per model. A built-in model arena for A/B testing with ELO leaderboards.

One command to start:

docker run -d -p 3000:8080 -v open-webui:/app/backend/data https://t.co/3jSpC5nmst

Open localhost:3000. You now own your AI stack completely.

154.8K stars. 172 releases. Native desktop apps for macOS, Windows, Linux.

The AI platform that doesn't answer to anyone but you.