AI/ML

ragflow93.7k★

RAGFlow is a retrieval-augmented generation engine built around deep document understanding, and it has grown into an agent platform on top of that. It handles the messy parts of RAG other frameworks hand-wave past: PDFs with tables, slides, spreadsheets and scanned images, with MinerU and Docling parsing. Recent releases added knowledge compilation into wikis, graphs and mind maps, agent memory, and delivery into chat apps like Discord, Telegram and Line. Apache 2.0. Self-hosting is a real project, not a docker run. You need 4+ CPU cores, 16+ GB RAM, 50+ GB disk, and x86 hardware, since there are no ARM64 images. The compose file brings up RAGFlow plus MySQL, Redis, object storage and a search backend: Elasticsearch by default, with Infinity, OpenSearch and OceanBase among the options. Template-based chunking is still the killer feature: you see and adjust how documents are split before they reach the index. Solo developers and small teams that want full control can self-host for free. Everyone else can use RAGFlow Cloud, currently $29/mo for 5 seats on Starter or $129/mo for 20 seats on Pro, with Enterprise adding on-premises or bring-your-own-cloud deployment. The catch is operational weight. Just chatting with a few documents? LlamaIndex or LangChain over a simple vector store ships faster. Note that v0.27 pulled the old GraphRAG and RAPTOR features from the UI, so check tutorials against your version.

headroom79.0k★

headroom strips the bloat out of everything an LLM agent reads before it hits the prompt, tool outputs, logs, RAG chunks, raw file dumps, conversation history. The reported cuts are large, 60 to 95 percent fewer tokens with the same answers, and the compression is reversible, so the original is cached and fetchable when the model actually needs it. Apache-2.0, local-first, and free: your content never leaves your machine. You can adopt it at whatever depth you want. Drop the Python or TypeScript SDK inline, run it as a zero-code local proxy, or wrap an agent directly, Claude Code, Cursor, Copilot, and Aider all supported, plus an MCP server. It also trims the model's output, not just its input, through verbosity steering and effort routing, and headroom learn mines your failed sessions for auto-corrections. Development is fast-moving, this is not a stale side project. For anyone running agents on metered tokens, the math is simple: less context in and out means a smaller bill, and the local proxy makes trying it nearly free of effort. Solo developers and small teams: the open Apache-2.0 build is the whole tool, use it. Larger teams wanting shared deployment get a managed enterprise offering on top, which is where the money is, cross-team memory and central management rather than a better compressor. The catch is trust in the compression. Cutting 90 percent of the tokens only works if the 10 percent kept is the right 10 percent, and reversible caching exists precisely because sometimes it is not. Watch the first few runs on real work before you wire it into production blind.

LiteLLM62.8k★

LiteLLM gives you one OpenAI-style API in front of 100+ model providers: OpenAI, Anthropic, Gemini, Bedrock, Azure, Ollama and the rest. Use it as a Python SDK, or run the proxy as a gateway with virtual keys, per-team spend tracking, budgets, rate limits, fallbacks and load balancing. The core is MIT; an enterprise folder is proprietary. Self-host the proxy with Docker and Postgres. It moves fast: a new minor version roughly every week with only the four most recent supported, so a pinned version falls out of support in about a month. A Rust rewrite is underway, targeting the end of 2026. Overhead is small for normal requests (about 8 ms at p95 in their own benchmark), but the Python proxy struggles with very large prompts under load. Everything most teams need is free, and SSO is free for up to 5 users. Enterprise adds SSO beyond that, SCIM, audit logs, secret managers, IP allowlists, team-scoped guardrails and 24/7 SLAs, priced by annual request volume with no public numbers. Small and mid-size teams: free. Large orgs with compliance needs: talk to sales. The catch: it holds every API key you own, and its security record demands attention. Two poisoned releases (1.82.7 and 1.82.8) were live on PyPI for about 40 minutes in March 2026, and critical advisories kept coming through September. Use the official Docker image, pin it, and patch fast.

laya35.1k★

Laya answers typed questions about text without generating any: pick one of these labels, give this a score, yes or no. Hand it a support ticket or an email and it returns probabilities in a single pass. It's an open-weight rival to TypeSafe's hosted Jev model, and it copies Jev's API, so an existing client switches by changing one URL. Apache 2.0, code and weights. It runs on CPU. The README puts one question at roughly 200 to 460 milliseconds on CPU and about 33 on a T4 GPU. There are three checkpoints of 322M to 421M parameters, one covering 100+ languages, plus a built-in HTTP server and MCP server. Jev charges $42 per billion input tokens; this costs whatever hardware you already have. mizorewww/laya-mlx ports it to Apple Silicon. Teams routing tickets, triaging email or gating agent actions at high volume: self-host it and fine-tune it. The README is blunt that out of the box it's near chance on real workflows, and says to treat it as a fast base to specialise, not a zero-shot engine. A fine-tune takes about 4-5 hours on Kaggle's free GPUs. The catch: its Jev comparisons use Jev's published numbers, not side-by-side runs, and with many options Jev wins clearly. Confidence scores behave differently too, so thresholds tuned on Jev need re-tuning.

Unlimited-OCR30.7k★

Unlimited-OCR is Baidu's open model for reading documents. Point it at a scan, a screenshot or a long PDF and it returns the text with layout tags in one pass instead of stitching pages together. It builds on DeepSeek-OCR, and code and weights are both MIT, so commercial use is free. Running it yourself means an NVIDIA GPU. It's a 3.3-billion-parameter model (about 6.7GB of weights), served through Hugging Face transformers, vLLM's prebuilt Docker image, or a custom SGLang wheel the repo ships. There's no app or UI: you write the script that feeds it pages. Baidu Cloud now hosts it as an API, free for a limited time (200 test pages for verified individuals, 1,000 for companies), but signup means real-name verification on a Chinese cloud. Solo: free on a rented GPU, or the Hugging Face demo. Small teams: one GPU box behind vLLM. Larger teams: add a queue, or stay on AWS Textract if you need forms and tables pre-extracted. The catch: loading it runs Baidu's own model code (trust_remote_code=True), and the hosted API sends your files to Baidu. Self-host sensitive documents, pin a model revision, and test on your own messy scans, since the benchmarks are Baidu's.

kev9.9k★

Kev answers typed questions about a block of text and returns probabilities your code can branch on. Route this ticket to billing or shipping. Is the customer angry. How urgent is this. No prose, one forward pass, one answer per question. Three sizes (0.8B, 4B, 9B) on Qwen3.5 bases, Apache-2.0, weights and training code included. The API copies TypeSafe's System One contract, so their Python SDK points at a local server with a URL change. Install is uv sync and one serve command. The 4B wants about 9 GB of GPU memory in bf16, the 9B about 19 GB, and both fit a 32 GB Mac. Five questions take tens of milliseconds on an H100, roughly 780 ms for the 4B on an M5, two seconds for the 9B. On Apple Silicon the older Qwen3 builds are still the quicker option. Solo developers and small teams doing ticket routing, moderation, or intent classification can run the 4B on hardware they already own. Be honest about why, though: hosted Jev costs $42 per billion input tokens, which is cheaper than any GPU you would rent to replace it. Run Kev for data residency, offline operation, or a fine-tune on your own labels. Not to save money. The catch is what Kev does not know. On one 900-ticket support suite the 4B loses badly to hosted Jev at spotting an angry customer, and on MMLU-Pro it scores 0.490 against Jev's 0.840, because the base model sets that ceiling. The 9B closes the tone gap to roughly a tie and the knowledge gap not at all. Narrow, well-specified decisions are the job. The server also binds to localhost with no authentication.

civitai7.3k★

Civitai is the community hub for sharing Stable Diffusion models, LoRAs, and checkpoints. Think of it as GitHub for AI image generation models: browse what others have trained, download fine-tuned versions, and share your own. Self-hosting requires Docker, Node.js 20+, PostgreSQL, and a fair bit of setup. The docker-compose gets you running but managing model storage at scale is the real operational challenge. Most people just use civitai.com directly. Useful for solo creators experimenting with image generation or teams building products on top of community models. The platform itself is free and open source. The catch: the self-hosted version is meant for development, not production. The hosted platform at civitai.com is where the community and model library actually live.

gpt-load7.2k★

GPT-Load puts one base URL and one access key in front of every model provider you use. Your app stops caring whether a request lands on OpenAI, Anthropic, Gemini, Bedrock, or Groq. Channels, credentials, models, and routing policy all live in a web console. MIT, Go, free. Deployment is Docker Compose with application-managed SQLite by default, MySQL or Postgres if you outgrow it. It binds to localhost, the right default for something holding every API key you own, so budget time for TLS and firewall work before exposing it. One file matters most: the encryption.key file decrypts all stored credentials, this version cannot rotate it, and losing it makes every saved credential unrecoverable. Solo devs with a single API key do not need this. Small teams running several providers who want per-key usage and cost visibility are the sweet spot. Above that, read the fine print: 2.0 runs as a single instance and shares no state, so horizontal scaling is off the table. LiteLLM is the better call at that size. The catch is the feature that draws the traffic. Alongside API keys, GPT-Load pools subscription accounts through OAuth, Codex, Claude, Antigravity, and Grok, behind one endpoint. Those flows are unofficial and can break whenever an upstream changes, and the README itself tells you to connect only accounts you are entitled to use. That is the real constraint, not boilerplate.

awesome-opensource-ai5.0k★

This is the 'awesome list' for AI. Models, tools, infrastructure, datasets, organized by category with brief descriptions and links to the actual projects. Awesome lists live or die by curation quality. This one focuses on 'truly open source,' not source-available, not 'open weights with a restrictive license.' That distinction matters when you're building on top of these tools. The list is maintained on GitHub and follows the awesome-re standards. The catch: awesome lists are snapshots. They go stale unless someone actively maintains them, and the growth spike suggests this was recently featured somewhere. The real question is whether it'll be maintained in 6 months. Also, 'curated' means one person's opinion of what's worth including; your needs might differ. Use it as a starting point, not a definitive source.

MOSS-TTS-Nano4.6k★

MOSS-TTS-Nano is a multilingual text-to-speech model with only 100 million parameters that runs in real time on a CPU. No GPU required. It now handles 20 languages, including English, Chinese, German, Spanish, French, Japanese, and Korean, with solid quality for its size. Small enough to embed in desktop apps, local demos, or lightweight web services. Apache 2.0. Runs via Python with standard ML dependencies, and there is now an ONNX CPU build that nearly doubles throughput. Models are on HuggingFace and ModelScope, finetuning code is published for custom voices, and recent additions include mlx-audio support for Apple Silicon and a browser reader extension. The deployment stack stays simple: no CUDA, no heavy inference server, a basic machine handles it. Free for everyone under a permissive license. Solo developers building voice features get real-time TTS without paying per-character API fees. Teams shipping products can embed it directly without usage limits. The catch: 100M parameters means tradeoffs in naturalness and expressiveness. If you need the best possible voice quality, larger models or paid APIs like ElevenLabs will sound better. This is the right call when you want speed, low cost, and local execution over peak fidelity.

mike4.4k★

Mike is an open-source AI legal platform for document processing and review. Built on Next.js with an Express API, Supabase for auth and storage, S3-compatible object storage for files, and your choice of LLM provider for the analysis. AGPL-3.0. Setup is significant. You need a Supabase project, an S3-compatible bucket (Cloudflare R2 works), API keys for at least one model provider, and LibreOffice for DOC/DOCX-to-PDF conversion. The README is sparse, so plan for some reverse-engineering. Pick this if you run a small practice or a legal-ops team and want AI document review without sending client files to Harvey, Spellbook, or Casetext. Solo: free, you pay your model bill, the setup curve is real. Small teams: same plus shared infra. Large firms: they pay for Harvey because the integrations matter and they don't want to maintain this themselves. The catch: legal AI is a confidence and accuracy game, and Mike is early. Docs are thin, the feature set is whatever the README implies, and there is no SOC 2 posture out of the box. Use this because you want to own the stack, not because it's a turnkey product.

nixtla4.0k★

TimeGPT predicts where your numbers are headed. Feed it a history of anything measured over time, daily sales, hourly server load, weekly signups, and it forecasts what comes next and flags the weird spikes. No training a model, no feature engineering, three lines of Python. The SDK is open source under Apache-2.0. Here is the important part. The SDK is open, the model is not. TimeGPT runs on Nixtla's servers, and your data goes to their API to get a forecast back. There is nothing to self-host, which is why setup is trivial, but it also means you are sending your numbers to a third party and paying per call. A free trial key lets you kick the tires. For prototyping and one-off forecasts, the free trial plus a few lines of code is impressive, you get a working forecast in minutes. For production, you are on a usage-based bill and a hard dependency on their uptime. Solo and small teams testing an idea: start free. Teams putting forecasts in front of customers: price the API against running your own model with Nixtla's open StatsForecast or Prophet. The catch is the closed model. You cannot audit it, you cannot run it offline, and if Nixtla changes pricing or pulls the service, your forecasts go with it. Open SDK, closed brain.

h3.c3.0k★

H3.c generates video with synchronized audio locally on a Mac. It's a from-scratch C inference engine for MiniMax's H3 model, written by the creator of Redis, with an interactive REPL that previews output right in your terminal. The code is MIT and a pleasure to read; local, private video generation with no cloud API is the pitch. The hardware is the gate. You want Apple Silicon with serious unified memory: peak usage runs into the tens of gigabytes depending on canvas size, plus about 37 GB of disk for the checkpoint. An SSD-streaming mode drops memory use to around 2 GB, but at a steep speed penalty at small canvas sizes. Build is a simple make with FFmpeg on PATH. This is for Mac owners with serious unified memory who want local generation, and for anyone who wants to read a modern diffusion pipeline in C. ComfyUI is the mainstream local workbench; Runway and Pika are the hosted alternatives. The catch: the MIT badge covers only the code. The model weights ship under MiniMax's custom community license, non-OSI, with an application process for US, EU, UK, and South Korea users, and the engine is useless without them. The author also frames the repo as working vertical slices, not a finished product, and canvas sizes and frame counts have sharp constraints.

MOSS-Image2.7k★

MOSS-Image is an open text-to-image model built for what image generators usually botch: readable text inside the picture. Posters, signs, sticky notes, Chinese included. You can also hand it a JSON layout saying where the title and each object go. It's from OpenMOSS, and code and weights are both Apache-2.0, so it's free for commercial work. Running it locally means Python, PyTorch and an NVIDIA GPU. The weights are roughly 27 GB at bf16, over half of it the text encoder, and the Gradio app can offload to CPU for smaller cards at the cost of speed. ComfyUI supports it natively, and community trainers already do LoRA fine-tuning. The model has no paid tier. MOSI, the team behind it, sells API access, but hasn't published an image price yet. Solo and small teams: free if you own a decent NVIDIA card. Larger teams: free, but test it against FLUX and Qwen-Image first. The catch: it's days old and the quality claims are the lab's own. The default is 50 sampling steps, so it isn't fast, and the community is already patching vertical color banding in the SFT model. Loading it also runs custom code via trust_remote_code=True.

edgequake2.3k★

EdgeQuake is a GraphRAG engine: it turns a pile of documents into a knowledge graph and combines vector search with graph traversal so an AI can answer multi-hop questions, the kind where the answer is spread across several documents. It's a Rust reimplementation of the LightRAG approach with a React UI, Apache-licensed and free. Running it is a real project. You need Postgres 16 with the pgvector and Apache AGE extensions, plus Docker Compose to wire it together. It also needs an LLM and embedding provider: point it at OpenAI or Anthropic and you'll pay per call, or run it against a local Ollama model for no API cost at all. For a developer building retrieval over their own documents who specifically wants the graph-plus-vector approach, EdgeQuake is a solid, self-hostable option, mostly solo and small teams comfortable with Postgres. The Rust core is fast and the code is documented. The catch is honesty about the payoff. On accuracy it's roughly a tie with LightRAG, so you're not buying a quality leap, you're buying a Rust implementation and a UI. And the pgvector-plus-AGE Postgres setup is a genuine dependency lift. If you just need basic RAG, a simple vector store ships faster. Reach for this when the graph structure is the point.

claude-real-video2.3k★

claude-real-video lets an LLM actually watch a video instead of guessing from a title. It pulls the frames that matter, using scene-change detection so it grabs a new frame when the picture changes, not every few seconds, deduplicates the near-identical ones, and optionally transcribes the audio with Whisper. Out comes a set of frames, a transcript, and a manifest you feed to Claude or any model. The core is MIT and free, and it all runs on your machine. Setup is a notch above pip-install because it leans on ffmpeg, the video-processing workhorse, which you install once at the system level. After that it is Python 3.10+ and a package install, with Whisper optional if you want transcription. Nothing leaves your laptop, which matters if the footage is sensitive. The free tier is the useful 90 percent: frame extraction, dedup, transcript. A one-time Pro unlock (founder price around $19, not a subscription) adds analysis on top, camera-movement classification, editing-rhythm detection, and a perception timeline of gestures and sound events. For most people wanting to hand a video to an LLM, free is plenty. Pay the $19 only if you are doing real video teardowns and want the extra structure. The catch is scope. This prepares video for a model, it does not understand it, the understanding still happens in whatever LLM you pipe the output into. It is a very good front door, not the whole house.

nimble2.3k★

Bespoke Nimble answers typed questions about a block of text. It returns the answer plus a probability for every option and never writes prose, so there is no JSON to parse. Bespoke Labs, the team behind Curator, fine-tuned Qwen3.5-9B on 2,676 curated examples and published the weights, the training data, and the full curation pipeline. It is an open take on TypeSafe's Jev, and jaredpalmer/kev is the other one to compare it with. Running it yourself is real work. The 9B weights alone are about 18 GB, so you need a big Apple Silicon Mac or an NVIDIA GPU with BF16, plus a merge step first. Bespoke measured roughly 106 ms per question on an H100 and 444 ms on an M5 Pro. A free public demo endpoint exists for trying it, not for production. The interesting part is the recipe, not the model. Their contrastive data curation writes pairs of examples that differ by one fact so the label flips, which teaches the model which evidence matters. Read that before building your own classifier. The catch: the repo has no license file. The weights are Apache-2.0 on Hugging Face, but the code has no stated terms, and the 90% agreement headline comes from 324 synthetic examples drawn from six source families. Bespoke built it in a day and says so.

llm-agents.nix2.2k★

llm-agents.nix packages every AI coding agent worth using as a Nix flake. Claude Code, Codex, Cursor Agent, Crush, Aider, GitHub Copilot CLI, Droid, Amp, Gemini CLI, OpenCode, and a dozen others all run via nix run github:numtide/llm-agents.nix#claude-code. MIT licensed, automatically updated daily. Nix users already know why this matters. Most AI coding agents ship as npm packages, curl-bash installers, or proprietary binaries that conflict with each other and bypass your shell environment. Wrapping them as Nix derivations means reproducible installs, no global pollution, and easy version pinning. The repo updates from upstream sources every day, so versions stay current without manual intervention. For Nix users running multiple AI agents, this replaces a directory of brittle install scripts with one flake. Solo: install it. Teams on NixOS: add it to your shared flake. Anyone else: not for you, this is Nix-specific tooling. The catch: most of these agents are themselves proprietary (Claude Code, Cursor, Copilot, Droid, Codex), so the Nix package is just a packaging convenience. You still need API keys, accounts, and licenses for the underlying services.

daVinci-MagiHuman2.1k★

DaVinci-MagiHuman does it in one model. No separate video generation, no separate voice synthesis, no stitching. One 15-billion-parameter transformer takes text and a reference image and jointly produces video and audio. The numbers are real: 5-second 1080p video in 38 seconds on a single H100. Supports Mandarin, Cantonese, English, Japanese, Korean, German, and French. Beats Ovi 1.1 (80% win rate) and LTX 2.3 (60.9% win rate) in human evaluation. The full model stack is released: base model, distilled model, super-resolution model, and inference code. From Shanghai's GAIR Lab and Sand.ai. The catch: you need serious hardware. An H100 for the fast inference numbers, and the 15B parameter model isn't running on a consumer GPU. No license file listed; check before commercial use. And 'joint audio-video generation' is still early. The 5-second clip limit means this is for avatars and short-form content, not video production.

JoyAI-Echo2.1k★

JoyAI-Echo is JD.com's open release for generating long video with synced audio from a text prompt. Not the usual five-second clip. It targets multi-shot sequences up to about five minutes and keeps the same character and voice consistent across shots. The weights are actually released, not just a paper and a demo page, which is the difference between a real tool and a press release. The catch arrives fast on hardware. You're looking at roughly 46GB of VRAM for the full setup and around 70GB of weights to download. That's an H100 or A100, data-center territory. There are reduced settings for smaller cards, with the obvious tradeoffs in quality and length. Read the license before you build anything on this. It ships under the LTX-2 Community License, which forbids commercial use. So it substitutes for Sora, Runway, Kling, and Veo for research, prototyping, and personal projects, but not for anything you plan to sell. For commercial long-form video you're back to the paid services, or to a permissively licensed model like the Wan and Hunyuan families. Between a non-commercial license and data-center GPU requirements, this is a research showcase for most people, not a production tool. Impressive that it exists and runs. Just know what you can and can't do with it.

JoyAI-Video-Edit2.0k★

JoyAI-Video-Edit edits video in real time from a natural-language instruction: point it at a live camera stream, tell it to swap the background or restyle the subject, and it edits frames as they arrive rather than waiting for the full clip. It's from JD.com's research arm, and both the code and the model weights are Apache 2.0, which is rarer than it should be. Now the hardware reality: the headline real-time number comes from a single NVIDIA B200, a data-center accelerator costing tens of thousands of dollars. The README doesn't say this; the paper does. Consumer GPU support is on the roadmap, not in the release. Setup is conda, CUDA wrangling, and external model dependencies that aren't bundled. Teams with data-center GPU access building live video pipelines, and researchers working on autoregressive diffusion, are the real audience. Runway and Pika are the hosted comparisons; Wan and HunyuanVideo are the open peers, though none target causal real-time editing. The catch: training pipelines aren't released, so you can run the model but not reproduce it, and a stronger checkpoint is already announced, making this one a waypoint. Free in license, expensive in silicon.

OnnxOCR1.9k★

OnnxOCR is a fast, multilingual OCR engine, the technology that turns images of text into actual text you can use. It is a rebuild of the popular PaddleOCR that strips out the heavy PaddlePaddle training framework and runs on ONNX Runtime instead, which makes it lean and quick. It reads Simplified and Traditional Chinese, English, Japanese, and more, and handles tables, document layout, and even license plates. Apache-2.0 and free. Setup is a pip install with Python 3.8 or newer. You can run it locally with a test script, stand it up as a JSON API, or launch a browser UI, and Docker support is included. Because it dropped the training framework, it runs well on edge devices and on both ARM and x86, which is the whole point: OCR without dragging a deep learning stack along. Accuracy is reported to match PaddleOCR 3.0. Developers who need to pull text from images or scanned documents and would rather not pay per-call cloud fees should look here. Solo and small teams get production-capable OCR for free, running on their own hardware. Larger teams processing high volumes save the most, since cloud OCR APIs bill per image. It is free at every scale. The catch is that you own the deployment and the accuracy tuning. Cloud OCR services like Google Vision or AWS Textract hand you an API and a support line; here you manage the models and the edge cases yourself. For high volume or privacy-sensitive work, that trade is usually worth it.

jeff1.6k★

Jeff is a set of small open models that answer multiple-choice, yes-or-no and scoring questions with a probability per option instead of generated text. It speaks the same request format as TypeSafe's closed Jev API, so it drops in for classification, routing and guardrail checks. Code is MIT, weights are Apache 2.0, and the training code builds on AutoJev from Denis Yarats of Perplexity. There are three models: 0.8B and 2B versions built on Qwen3.5, plus a heavier Gemma 4 variant. The small one needs 1.7GB and answers in about 22 milliseconds on a workstation GPU, 28 on an M4 Max, or about half a second on a big CPU. Setup is uv, a Hugging Face download and jeff-serve, which listens on localhost by default with optional key auth. Training code is included, and the author reports a voice-command fine-tune jumping from 32% to 96% accuracy in half an hour on one GPU. Teams sorting tickets, intents or sentiment at volume should self-host it instead of paying Jev's $42 per billion input tokens. Its benchmark average lands just under Jev's published number, and an outside user re-ran the suite and matched the author's scores. NandhaKishorM/laya is smaller and covers 100+ languages; jaredpalmer/kev scales up to 27B. The catch: the Jev comparison uses Jev's published figures on a different sample, not side-by-side runs, and on reasoning-heavy tests like BBH and WinoGrande Jeff trails badly. It's English and text only. The latest version also trained on two popular intent benchmarks, so those scores are no longer zero-shot.

gemma-tuner-multimodal1.5k★

Gemma Tuner lets you fine-tune Google's Gemma 4 and 3n models on your Mac, no cloud GPU required. Text, images, and audio, all via Apple Silicon's MPS backend. You bring a CSV of training data, point the wizard at a HuggingFace checkpoint, and watch the training run on your local GPU with a real-time visualizer showing loss curves, attention heatmaps, and memory pressure. The 2B and 4B parameter models are the sweet spot for consumer hardware. 16GB RAM minimum, 32GB recommended. It streams training data from Google Cloud Storage or BigQuery for datasets larger than your SSD. Exports land in HuggingFace SafeTensors format with guides for Core ML and GGUF conversion if you want to deploy on-device. Solo ML practitioners get local fine-tuning without paying $2-5/hr for cloud GPUs. Small teams prototyping custom Gemma models can iterate locally before scaling to cloud training. The wizard CLI makes the setup approachable even if you're not a PyTorch expert. The catch: Gemma only. No Llama, no Mistral, no other model families. Larger Gemma weights (26B+) are not supported. Audio fine-tuning on non-Mac platforms requires CUDA. And you still need a HuggingFace account with Gemma's license accepted before you can download the weights.

pyre-code1.3k★

Pyre-Code is a self-hosted coding practice platform for machine learning. 68 problems that walk you from implementing ReLU to building attention mechanisms, RLHF pipelines, and diffusion models. Browser-based editor with instant test feedback and reference solutions. No GPU required. Running it yourself takes a Next.js frontend and a FastAPI backend with SQLite for progress tracking. Standard Docker setup, nothing exotic. The whole point is to run it locally or on a team server so you can practice without leaking code to a third-party platform. ML engineers prepping for interviews or deepening their understanding of model internals will get the most from this. It's not a course or a tutorial: it's hands-on implementation practice where you write the code and the tests tell you if you're right. The catch: 68 problems is a fixed set. No community contributions yet, no problem editor, and the difficulty curve assumes you already know Python and basic linear algebra.

Boogu-Image998★

Boogu-Image is an open source image-generation and editing model you run yourself. It comes in Base, Turbo, and Edit variants for text-to-image, fast photorealistic generation, and image-to-image editing, with notably strong Chinese and English text rendering. Code is Apache-2.0 and the weights are on Hugging Face and ModelScope, all free. Self-hosting a model like this means real hardware. You need a capable GPU and the patience to set up inference, and there is no official hosted API to fall back on. At version 0.1 it is early, so expect rough edges. The payoff is full control and no per-image cloud bill, which adds up fast once you generate at volume. This is for ML practitioners and builders who want a permissively-licensed image model they can run on their own GPUs, especially if bilingual text rendering matters to them. Solo with a good GPU: free to run. Teams generating at scale: free software, but budget for the hardware. If you want a turnkey API and no ops, the proprietary options like DALL-E, Midjourney, Firefly, and FLUX Pro are where you pay for convenience. The catch is the hardware and the early stage. This is weights and code, not a service, so the GPU and the setup are on you, and at v0.1 it is more a capable starting point than a finished product. If you have the silicon and want to own your image pipeline, it is a strong free option. If you do not, an API is less hassle.