Best Free Top 17 Open-Source AI Github Repos Powering Local-First Intelligence

Seventeen open-source repositories now form a complete, five-layer artificial intelligence stack that runs entirely on local hardware — from Ollama’s 179,000-star inference engine and exo’s Thunderbolt 5 RDMA clustering to InvokeAI’s production-grade creative studio.¹ This guide dissects every layer, sub-repository, fork, licensing constraint, language breakdown and hardware requirement so you can build, audit and deploy the entire “Century Stack” without sending a single token to a cloud API. Whether you are clustering Apple Silicon Macs for 70B-parameter inference, running autonomous penetration tests with Strix, or generating 720p cinematic video on a single RTX 4090 via Wan 2.2, the architecture below maps every dependency, every integration point and every operational ceiling you will hit in production.

Key Takeaways

• Largest inference community: Ollama at ~179,000 GitHub stars with official Python, JavaScript and VS Code extensions under MIT licence.
• Fastest cluster interconnect: exo achieves 99% latency reduction via Thunderbolt 5 RDMA and 3.2× tensor-parallel speedups across 4 devices.
• Zero-dependency speech-to-text: whisper.cpp runs OpenAI Whisper with no Python runtime, supporting CUDA, Metal, ROCm, Vulkan and Core ML offload.
• Most complete coding agent: Cline at 66,900 stars ships Plan/Act separation, shadow-workspace Git isolation and 4.5M+ VS Code installs.
• Enterprise RAG without vector DBs: RAGFlow uses Elasticsearch or InfiniFlow’s native Infinity engine for hybrid full-text plus semantic search.
• Lightest search engine: Vane (formerly Perplexica) reduced its Docker footprint from 1.8 GB to 220 MB via Next.js refactor.
• Real-time music synthesis: ACE-Step 1.5 generates full songs in under 4 GB VRAM using FSQ tokenization and intrinsic RL alignment.

---

Layer 1 — Foundational Inference & Hardware Aggregation

Layer 1 pools physical compute — Apple Silicon unified memory, CUDA cores, CPUs and Thunderbolt-linked clusters — and serves foundational models including LLMs, speech transcription, video generation and music synthesis entirely offline. Ollama, exo, whisper.cpp, Wan 2.2 and ACE-Step 1.5 collectively cover every modality a local-first stack requires, from text generation to 720p cinematic video at 24 fps.

Ollama — the 179K-star inference backbone

Ollama is written in Go and C++ under an MIT-compliant licence and serves as the universal local inference layer. Its official ecosystem includes ollama-python (10.4k stars), ollama-js (4.4k stars) and ollama-vscode for editor integration. Community GGUF models pulled through Hugging Face resolve via a distinct runtime path using an Ollama-compatible image manifest with layers for model weights, chat templates, multimodal projectors and system-prompt defaults.

The VS Code extension requires Visual Studio Code 1.127+ and Ollama 0.17.6+ for cloud model sign-in. Unlike standard GGUF templates stored in tokenizer files, Ollama translates conversations into model-specific formats via Go-based templates — a design choice that keeps the runtime lightweight while supporting dozens of chat formats out of the box.

References: Official GitHub repository · Ollama.com documentation · Python SDK (GitHub)

exo — Thunderbolt 5 RDMA clustering for heterogeneous devices

exo (Apache-2.0, 47,100 stars) automatically discovers peers on a local LAN with zero configuration and shards model weights via topology-aware auto-parallel. Its Day-0 Thunderbolt 5 RDMA support achieves up to 99% latency reduction between clustered devices, while tensor parallelism yields 1.8× speedups on 2 devices and 3.2× on 4.² The language breakdown is Python 68.3%, Svelte 19.3%, Swift 5.8%, TypeScript 3.7%, Rust 1.3% and Nix 0.8%.

The active MLX-native fork MLXPorts/exo-mlx eliminates gRPC and mDNS overhead in favour of persistent lightweight sockets with Python 3.14 free-threading. Multi-tenant isolation is handled via the EXO_LIBP2P_NAMESPACE environment variable, enabling independent clusters on a single physical network.

References: Official GitHub repository · exo-mlx MLX fork (GitHub)

whisper.cpp — zero-dependency speech-to-text on any silicon

whisper.cpp (MIT, 53,200 stars) is a pure C/C++ reimplementation of OpenAI’s Whisper with zero runtime heap allocations. Hardware acceleration spans Apple Silicon (NEON, Accelerate, Metal, Core ML), Intel (AVX/AVX2/AVX-512, OpenVINO), NVIDIA (CUDA, cuBLAS), AMD (ROCm, Ryzen AI NPU), Vulkan, Ascend NPU and Moore Threads GPUs. Quantized tiny models run under 270 MB RAM.

References: Official GitHub repository · Go bindings documentation

Wan 2.2 — Temporal MoE video generation at 720p/24fps

Wan 2.2 (Apache-2.0, 17,300 stars) implements a Temporal Mixture-of-Experts architecture in video diffusion, separating denoising across timesteps with specialised expert models at zero additional compute cost. Trained on +65.6% more images and +83.2% more videos than Wan 2.1, it generates cinematic 720p at 24 fps locally on a single RTX 4090 via an advanced 16×16×4 VAE.

The Wan-Video organisation maintains companion repositories including Wan-Dancer (human pose/motion, 420 stars), Wan-Animate-2 (character animation, 288 stars), Wan-skills (agent skills, 74 stars) and a dedicated diffusers fork for Hugging Face orchestration.

References: Official GitHub repository · Wan-Animate-2 (GitHub) · Wan-skills agent integration

ACE-Step 1.5 — commercial-grade music synthesis under 4 GB VRAM

ACE-Step 1.5 (MIT, 12,400 stars) uses a discrete language-model planner with Chain-of-Thought to translate text prompts into hierarchical song blueprints. Finite Scalar Quantization compresses audio latents from 25 Hz to 5 Hz, while intrinsic reinforcement learning aligns generation quality without external reward models. It supports LoRA fine-tuning from a few audio files, editing paradigms like repainting and vocal-to-BGM conversion, and runs across 50+ languages in under 4 GB VRAM.

References: Official GitHub repository · ACE-Step-DAW (GitHub, AGPL-3.0) · Side-Step GUI companion

┌────────────────────────────────────────────────────────┐
│             LAYER 5: END-USER APPLICATION UI           │
│   • Jan Desktop Client   • InvokeAI   • Formbricks     │
└───────────────────────────┬────────────────────────────┘
                            ▼
┌────────────────────────────────────────────────────────┐
│          LAYER 4: SECURE SECURITY PEN-TESTING          │
│   • Strix Security Agent (Multi-agent offensive tool)  │
└───────────────────────────┬────────────────────────────┘
                            ▼
┌────────────────────────────────────────────────────────┐
│         LAYER 3: RETRIEVAL & CONTEXT HARVESTING        │
│   • Crawl4AI  • Browser Use  • RAGFlow  • Vane        │
└───────────────────────────┬────────────────────────────┘
                            ▼
┌────────────────────────────────────────────────────────┐
│        LAYER 2: AGENT ENGINE & CODING FRAMEWORKS       │
│   • Cline Coding Agent     • GitHub Spec Kit           │
└───────────────────────────┬────────────────────────────┘
                            ▼
┌────────────────────────────────────────────────────────┐
│      LAYER 1: FOUNDATIONAL INFERENCE & HARDWARE        │
│   • Ollama  • exo  • whisper.cpp  • Wan 2.2  • ACE    │
└────────────────────────────────────────────────────────┘

Layer 2 — Agent Engine & Coding Frameworks

Layer 2 powers autonomous agents that analyse directories, modify workspaces, execute shell commands and run verified spec-compliant builds. Cline’s 4.5-million-install VS Code extension and GitHub’s spec-kit together establish the coding agent and specification governance layer that every higher tier depends upon for safe, auditable code modification.

Cline — Plan/Act separation with shadow-workspace isolation

Cline (Apache-2.0, 66,900 stars, TypeScript 97.4%) ships across four surfaces: the VS Code extension (saoudrizwan.claude-dev, 4.5M+ installs), an npm CLI (npm i -g cline) with tmux pane orchestration, a Kanban package for parallel agent executions across isolated Git worktrees, and a Node.js SDK. Its strict Plan/Act separation maps file systems in Markdown before executing changes, while Shadow Workspace snapshots enable automated rollbacks via /undo.

References: Official GitHub repository · VS Code Marketplace listing · Cline Kanban (GitHub)

spec-kit — executable specifications as the single source of truth

GitHub’s spec-kit (MIT, 131,600 stars, Python 96.5%) establishes Spec-Driven Development where executable specification files and project constitutions eliminate prompt drift. Six sequential commands — /speckit.constitution through /speckit.implement — manage the full pipeline. It supports 29 named AI coding agent wrappers plus a Generic API adapter, installing skills into directory enclaves like .claude/skills/ rather than running raw scripts. Over 70 community extensions hook into Jira, Azure DevOps and GitHub Issues.

References: Official GitHub repository · Demo application (GitHub)

How Cline’s Shadow Workspace prevents catastrophic edits

Before any modification, Cline snapshots the workspace state into a Git-based enclave. If subsequent tests or builds crash, the /undo command triggers an automated rollback to the last verified state. The Lazy Teammate mode parameter enforces minimal code edits, preventing unnecessary refactoring across the codebase.

# Spin up a local exo cluster and serve through Ollama
exo --discovery udp --namespace my-cluster
ollama serve &
ollama run qwen3:32b --keep-alive 30m

# Verify cluster topology
exo --info | grep -E "peers|shards|rdma"

# Run Cline in headless mode against local endpoint
cline --provider ollama --model qwen3:32b \
  --task "Refactor auth module per /speckit.specify"

---

Layer 3 — Retrieval-Augmented Generation & Context Harvesting

Layer 3 crawls, sanitises and normalises messy data from HTML, video, PDFs and web links into clean Markdown and structured JSON, building the grounding index for local search. Six repositories — Crawl4AI, Browser Use, changedetection.io, RAGFlow, Vane and MarkItDown — collectively handle every ingestion, monitoring and retrieval pattern an offline RAG pipeline requires.

Crawl4AI — async LLM-ready web harvesting at 79,500 stars

Crawl4AI (Apache-2.0 with attribution, Python 98.8%) features a Memory-Adaptive Dispatcher that evaluates active RAM and CPU in real-time, dynamically scaling headless Playwright instances. Navigation supports standard BFS/DFS crawls alongside advanced info-foraging algorithms that halt the moment sufficient data matching the target query is identified. Structured extraction uses CSS queries, LLM-driven schema generation or multi-modal vision prompts.

References: Official GitHub repository · Cloud SDK (GitHub) · MCP server integration

RAGFlow — enterprise RAG without traditional vector databases

RAGFlow (Apache-2.0, 89,300 stars; Go 46.4%, Python 31.9%, TypeScript 17.3%) replaces conventional vector stores with Elasticsearch or InfiniFlow’s native Infinity database for robust hybrid full-text and semantic search.³ Its DeepDoc OCR parser uses YOLO-based layout analysis to extract complex figures, columns and tables from scanned PDFs. Visual ETL pipelines provide drag-and-drop ingestion with Parser, Transformer and Indexer nodes, while RAPTOR hierarchical trees enable multi-hop logical reasoning over large document directories.

References: Official GitHub repository · RAGFlow documentation site

Vane — the 220 MB citation-validating meta-search engine

Vane (MIT, 36,500 stars, TypeScript 98.8%), formally rebranded from Perplexica under commit SHA 39c0f198 on 9 March 2026, runs a three-phase architecture: Analytical Routing refines user intents, Metasearch Fetching queries a local anonymous SearxNG instance, and Embeddings Fusion re-ranks passages against the original query with URL citations. The Next.js refactor reduced Docker footprints from 1.8 GB to 220 MB with automatic Server-Sent Events stream recovery.References: Official GitHub repository · Epoch UI companion (GitHub)

Repository	Stars	Forks	Licence	Primary Language
Ollama	~179,000	—	MIT	Go / C++
spec-kit	131,600	11,800	MIT	Python
browser-use	110,700	12,200	MIT	Python
RAGFlow	89,300	10,500	Apache-2.0	Go / Python / TS
Crawl4AI	79,500	8,200	Apache-2.0	Python
Cline	66,900	7,200	Apache-2.0	TypeScript
whisper.cpp	53,200	6,100	MIT	C++ / C
exo	47,100	3,500	Apache-2.0	Python / Svelte
Vane	36,500	4,100	MIT	TypeScript
InvokeAI	28,000	2,900	Apache-2.0	Python / TS

The highest-leverage investment in 2026 is not a bigger model but a better harness. Architecture, training method and orchestration now matter more than raw parameter count.

The Century Stack architectural thesis

Layer 4 — Autonomous Security & Operations

Layer 4 hosts collaborative agents that actively exploit application logic to confirm vulnerabilities and run continuous user-feedback loops at scale. Strix performs real exploit verification inside isolated Docker sandboxes and auto-generates fix pull requests, while Formbricks provides the open experience-management survey platform that closes the feedback loop for every product team.

Strix — active exploit verification with auto-fix PRs

Strix (Apache-2.0, Python 90.7%, Jinja 4.7%) runs target application code dynamically inside isolated Docker sandboxes and actively exploits weaknesses to construct working Proof-of-Concepts — eliminating the false-positive problem of standard vulnerability scanners. AI-generated security patches are submitted directly back to developer repositories as ready-to-merge pull requests. CI/CD integration uses -n non-interactive mode with fetch-depth: 0 to analyse only changed files, blocking insecure commits before merge.

References: Official GitHub repository · Open weights on vendor release page

Formbricks — open experience management at 12,800 stars

Formbricks (AGPLv3, TypeScript 97.8%) is built on Next.js, React, TailwindCSS, Prisma and Auth.js. It embeds native SDKs into React, Next.js and mobile applications to trigger contextual, event-driven micro-surveys. Real-time analytics dashboards monitor individual survey pathways, user cohort segmenting and automated response routing, with native integrations to Slack, Notion, Zapier, Salesforce, HubSpot and custom webhooks.

References: Official GitHub repository · Formbricks.com documentation

---

Layer 5 — Creative Production & Post-Processing

Layer 5 houses the generation studios and media pipelines that render high-definition imagery, synthesise video and polish low-resolution outputs on consumer hardware. InvokeAI’s node-graph orchestration with DyPE high-resolution stabilisation and Upscayl’s 16× Real-ESRGAN upscaling via NCNN Vulkan together close the loop from raw generation to print-ready output.

InvokeAI — production-grade creative studio with node-graph pipelines

InvokeAI (Apache-2.0, 28,000 stars; Python 56.1%, TypeScript 43.8%) provides a visual unified canvas supporting interactive generation, outpainting, inpainting and spatial selection via freehand or polygon Lasso tools. Its node-graph orchestration exposes low-level generation as visual maps. Dynamic Pixel Evaluation (DyPE) prevents warping above 1536 px, while local LLM adapters like Qwen 2.5 Instruct enrich prompts and LLaVA vision models handle image-to-prompt translation. The org maintains 10+ companion repositories including invoke-training (LoRA/SFT), PyPatchMatch (inpainting) and GFPGAN (face restoration).

References: Official GitHub repository · invoke-training LoRA suite · Community installer (GitHub)

Upscayl — 16× super-resolution without PyTorch

Upscayl (AGPLv3, 48,800 stars; TypeScript 90.6%) enlarges images up to 16× without print-quality degradation by routing all processing through Vulkan-compatible GPUs via the NCNN framework, completely bypassing PyTorch runtimes. Its native C/C++ backend (upscayl-ncnn, 457 stars) runs Real-ESRGAN models, while the custom-models repository (507 stars) curates community upscalers including NMKD, Remacri, HFA2k, Ultrasharp and LSDIRCompact. Automatic scale detection reads filename suffixes like x2 or 2x to set target parameters dynamically.

References: Official GitHub repository · NCNN backend engine (GitHub) · Community model repository

When 17 repositories under permissive licences replace a $200/month cloud AI subscription, the economics of intelligence fundamentally shift.

The Century Stack economic argument

Hardware Tiering & Operational Limits

The Century Stack operates across three hardware tiers: Edge (8–16 GB RAM) for 1.3B–8B models, Prosumer (32–64 GB) for intermediate workloads, and Datacenter (128 GB+ VRAM) for heavy MoE variants and multi-device exo sharding. Operators must also budget for agent token burn and ensure crawl/security operations carry explicit authorisation.

---

Century Stack FAQ

The most common questions about the Century Stack concern licensing compatibility, minimum hardware requirements, whether the stack truly runs fully offline, how exo clustering compares to cloud inference, and which repositories are production-ready versus experimental. In short: all 17 repositories use permissive licences (MIT, Apache-2.0 or AGPLv3), the minimum viable stack runs on 8 GB RAM, and every layer operates without internet connectivity once models are downloaded.

Can the entire Century Stack run without internet access?

Yes. Once model weights are downloaded via Ollama or Hugging Face, every layer from inference through creative generation operates entirely offline. Crawl4AI, Browser Use and changedetection.io require network access by design (they are web tools), but all inference, agent execution, RAG retrieval, security testing and creative generation run locally without cloud calls.

What is the minimum hardware to run the full stack?

For a minimal viable stack (Ollama with a 3B model, whisper.cpp tiny, Vane search and Cline), 16 GB unified memory on Apple Silicon or 16 GB system RAM with a 6 GB GPU suffices. For the full stack including Wan 2.2 video generation and InvokeAI, 32 GB RAM and a 12 GB+ VRAM GPU is recommended. exo clustering can pool multiple 8 GB devices for larger models.

Is exo production-ready for multi-device inference?

exo supports MLX and tinygrad engines fully, with PyTorch and llama.cpp in progress. Discovery via UDP, manual peer entry and Tailscale is fully supported. Thunderbolt 5 RDMA and GRPC peer networking are production-ready. NCCL peer networking is still under development. For Apple Silicon clusters, exo-mlx is the recommended fork.

How does RAGFlow differ from LangChain or LlamaIndex RAG setups?

RAGFlow uses Elasticsearch or InfiniFlow’s Infinity database instead of dedicated vector stores like Pinecone or Chroma. It includes a built-in YOLO-based OCR parser for scanned documents, visual drag-and-drop ETL pipelines, and RAPTOR hierarchical summarisation for multi-hop reasoning. The result is a self-contained enterprise RAG system that does not require external vector database infrastructure.

Is Strix legal to run against my own applications?

Yes, Strix is designed for authorised security testing of your own applications and infrastructure. It runs exploits inside isolated Docker sandboxes and generates fix PRs automatically. However, running automated penetration scans against systems you do not own or lack explicit written authorisation to test violates computer misuse laws in most jurisdictions. All operations should run in isolated environments.

What happened to Perplexica and why was it renamed to Vane?

Perplexica was formally rebranded to Vane under commit SHA 39c0f198 on 9 March 2026. The rebrand involved updating Docker registry paths from itzcrazykns1337/perplexica to itzcrazykns1337/vane, moving container filesystem environments from /home/perplexica to /home/vane, and refactoring backend routes into Next.js to reduce the Docker footprint from 1.8 GB to 220 MB.

Can ACE-Step 1.5 generate commercial music without licensing issues?

ACE-Step 1.5 is released under the MIT licence, which permits commercial use without restriction. The model generates original compositions from text prompts and does not sample or interpolate existing copyrighted recordings. LoRA fine-tuning on custom audio files is supported for personalisation, but operators should ensure their training data carries appropriate rights.

Which repository has the most active community in 2026?

By GitHub stars, Ollama leads at approximately 179,000 stars. By fork-to-star ratio indicating active contribution, browser-use (110,700 stars, 12,200 forks) and spec-kit (131,600 stars, 11,800 forks) show the highest community engagement. Cline’s 4.5 million VS Code installs make it the most widely deployed individual tool in the stack.

How do I connect Cline to a local Ollama endpoint?

Point Cline’s provider configuration to your local Ollama instance. Using the CLI: run cline with the provider flag set to ollama and specify your model name. The connection uses Ollama’s native API at localhost:11434. No cloud API keys are required. For exo-clustered models, point to the exo gateway endpoint instead.

Strategic Verdict — Where to Focus Next

The Century Stack represents the first complete, licence-compatible, fully local alternative to cloud AI subscriptions — and its architecture proves that harness design, clustering efficiency and spec-driven governance now deliver more capability per dollar than raw model scale. For teams evaluating local-first AI in 2026, the priority order is: secure your inference layer (Ollama + exo), govern your agents (Cline + spec-kit), ground your retrieval (RAGFlow + Vane), and only then invest in creative and security tooling.

The structural lesson from 17 repositories is that no single project dominates. Ollama wins on community gravity, exo on interconnect innovation, Cline on developer adoption, RAGFlow on enterprise retrieval and InvokeAI on creative depth. The stack’s power is compositional: each layer’s output feeds the next, and the entire pipeline remains auditable, forkable and free from vendor lock-in.

The honest watch-list for the next quarter: exo’s NCCL peer networking reaching production parity, Cline’s JetBrains marketplace client going fully open-source, Wan 2.2’s community extensions stabilising around a unified ComfyUI interface, and whether spec-kit’s 70+ community extensions consolidate into an official governance standard. If those four milestones land, the Century Stack transitions from impressive architecture to default infrastructure.

---

Sources and Further Reading

1. Ollama, “ollama/ollama — Get up and running with large language models”, GitHub repository, MIT licence, ~179,000 stars, 2026. ↩
2. exo-explore, “exo — Run your own AI cluster at home with any devices”, Apache-2.0, 47,100 stars, Thunderbolt 5 RDMA documentation, 2026. ↩
3. InfiniFlow, “RAGFlow — Open-source RAG engine based on deep document understanding”, Apache-2.0, 89,300 stars, 2026. ↩
4. ggml-org, “whisper.cpp — Port of OpenAI’s Whisper model in C/C++”, MIT, 53,200 stars.
5. Wan-Video