AI/ML

ragflow90.9k★

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.

headroom73.4k★

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.

LiteLLM59.4k★

LiteLLM is a proxy and Python library that puts a unified OpenAI-compatible API in front of 100+ LLM providers: OpenAI, Anthropic, Gemini, Cohere, Azure, Bedrock, Ollama, and more. Write your code once using the OpenAI format and switch providers by changing one line. Run it as a proxy server and you get rate limiting, cost tracking, fallback routing, and load balancing across providers. Teams use it to control which models engineers can call, track spend per team, and add retry logic without touching application code. MIT-licensed, free to self-host. Engineering teams building on multiple LLMs or managing costs across a company get the most value from the proxy. Individual developers using it as a Python library just want to avoid rewriting LLM calls when switching providers. Both use cases are free. The catch: the proxy adds latency. Not much, usually under 10ms, but it is a network hop. And the feature set moves fast enough that staying current requires attention.

OpenMAIC38.5k★

OpenMAIC turns a topic into a classroom of AI agents that teach and argue while you watch. AI teachers lecture while AI peers discuss and push back, so what you take away comes out of the exchange instead of one flat chatbot answer. Built by Tsinghua University researchers, grounded in a paper published in the Journal of Computer Science and Technology, and free to run. You run it yourself and bring your own model keys. Recent releases added a Pro Mode that turns any generated slide into an editable canvas, plus MP4 export, so a session can leave as a video file instead of living in a browser tab. Setup is a build step and API keys, not a one click install, and output quality tracks whichever model you point it at. The big change since spring: the project relicensed from AGPL-3.0 to MIT in June 2026. That takes the legal question off the table for anyone who wanted to embed this in a commercial product or offer it as a hosted service. Solo learners and teachers: run it locally and pay only for tokens. Teams building training content: usable now, and MIT means you can fork it into your own stack without a lawyer. The catch: multiple agents means multiplied token bills. A thirty minute session with three agents costs roughly three times what the same ground covered by a single chatbot would, and video export adds render time on your own machine. It is still an academic codebase, so expect rough edges where a product would have polish.

Langfuse34.7k★

Langfuse is the observability platform for LLM applications. Instrument your code with a few SDK lines and every call becomes a trace: prompts, completions, latency, token costs, quality scores over time. Basically Datadog for your LLM stack, and one of the standard picks in the space. The core is open source and self-hostable for free. Version 4 landed as a breaking major, and it moved real capability into the self-hosted edition: full-text search across traces, a filter search bar, monitors and alerts, faster observation and metrics APIs, and the in-app agent is no longer enterprise-only. Upgrading from v3 means walking their migration guide, so plan the jump rather than winging it. Self-hosting runs on Docker Compose or Kubernetes with Postgres and ClickHouse behind it. Cloud pricing restructured: the free Hobby tier gets you started, Core is $29/mo, and Pro jumps to $199/mo. Solo: Hobby or self-host. Small teams: Core covers most needs, or self-host to skip per-observation math. At scale, self-hosting wins on cost long before the Pro tier stops stinging. The catch: Langfuse only watches LLMs. General app monitoring still needs Datadog or SigNoz, the space breeds new competitors monthly, and the breaking major means every v3 self-hoster owes an upgrade project before they see any of this.

onyx32.1k★

Onyx is the self-hosted answer to enterprise ChatGPT, and its value is in where it plugs in. It indexes Slack, Google Drive, Confluence, GitHub, and 50-odd other sources, then answers questions about your own material with citations pointing back at the source document. The Community Edition is MIT licensed and covers chat, agentic RAG, custom agents, web search, code execution, and artifacts. Self-hosting comes in two shapes and the gap between them matters. Lite runs in under 1GB of memory on a simplified stack. Standard is the full system: vector and keyword indexing, background workers, ML inference servers, Redis, and MinIO blob storage, deployed through Docker, Kubernetes, or Helm. Standard is a real deployment with real operational weight, not a weekend project. The Enterprise Edition is where the money sits, and the split is defensible: SSO and SAML, role-based access control, analytics, query auditing, and whitelabeling. Solo and small teams get everything meaningful for free. Onyx Cloud has a free tier if you would rather not run it at all. The catch is that RBAC line. Permission-aware search, where the assistant only surfaces documents a given person is allowed to see, is exactly what a company with sensitive material needs, and it sits on the paid side. That is fair monetization, but price it before you roll this out company-wide.

Unlimited-OCR26.0k★

Unlimited-OCR is Baidu's open model for turning images and PDFs into text. Point it at a scanned contract, a multi-page report, or a screenshot full of text and it reads the whole thing in one pass, even very long documents. It handles single images, batches, and full PDFs, with streaming output so you see results as they parse. The weights are on Hugging Face and ModelScope under the MIT license, which means free to use, including commercially, with no strings. Running it yourself is where the cost shows up. This needs an NVIDIA GPU, CUDA 12.9, Python 3.12, and a recent PyTorch and transformers stack. You can run it through plain transformers or through SGLang for faster batch serving. It builds on DeepSeek-OCR, so the lineage is solid, but you are still standing up GPU infrastructure and a model server. There is no hosted API here, no dashboard, no support line. You bring the hardware. For solo work, the Hugging Face demo is free to try and you can run it on a rented GPU when you have a real job. Small teams that already process documents will want a dedicated GPU box or a cloud GPU. Larger teams treating OCR as a pipeline should put SGLang behind a queue. If you need OCR as a managed service with an SLA, look at a cloud vendor instead. The catch: MIT covers the code and weights, but accuracy on messy real-world scans is the thing you have to test on your own documents before trusting it. No benchmark replaces running it on your actual files.

awesome-free-llm-apis7.7k★

This is a maintained list of permanently free LLM API endpoints with API keys. Not trials, not 'free for 30 days,' but free-tier APIs you can actually build on. The list is organized by provider with rate limits, model availability, and key details. CC0 licensed, so you can do whatever you want with the information. The catch: 'permanently free' is a strong claim. Free tiers change. Rate limits tighten. Providers shut down. This is a living document that's only as good as its last update. And free LLM APIs often have significant rate limits. Fine for prototyping, not for production traffic. Always have a paid fallback for anything customer-facing.

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-load6.8k★

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-ai4.8k★

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.4k★

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.2k★

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.

kev2.8k★

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.

h3.c2.7k★

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.

claude-real-video2.2k★

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.

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.

edgequake2.1k★

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.

JoyAI-Echo2.0k★

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.

llm-agents.nix2.0k★

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.

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.

JoyAI-Video-Edit1.9k★

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.

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-Image987★

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.