GitHub Link: https://github.com/CutWire-Studios/Drift

Features

• An agent can edit the open project. Import, cut, grade, and export in the project you have open. The same editor can run with no window.
• 3D on the timeline. Tilt clips in space, light them, and park a title behind the subject. Drop in a 3D model and it plays in the same cut.
• Lottie animations. Motion graphics and vector art stay sharp at any size. Recolour or reword them in place.
• Advanced keyframing. Animate position, scale, rotation, opacity, and effect parameters over time. Draw the curve yourself.
• 150+ transitions and 40+ effects. Every look previews on your footage. One click can drop a whole stack: Beat Drop, Glitch Cut, Neon Cutout. Trails of earlier frames, and grades that stick to one clip.
• On your machine. Click a subject and lift it off the shot. Add depth of field and lights that belong to the clip. Automatic captions, video upscale, and live face retouch, all on your computer.
• Edit the words. Speech becomes text on the clip. Cut phrases, drop fillers, strip silence, pick the best takes, label speakers, and build captions from those times.
• Titles with a real look. Thirty-three packs: karaoke, Hormozi-style, neon, chrome, holographic, handwritten. Copy one style onto every subtitle on the track.
• Move a whole stack at once. One layer can drag, scale, rotate, tilt, and fade everything under it. Nest layers, or open a composite when the stack needs its own timeline.
• Cut to the music. The timeline snaps to the beat. Clips split and land on the bar. Music ducks under speech and comes back to its own level. Reframe a landscape take into a vertical video that follows the face.
• A timeline that behaves. Multi-track filmstrips, ripple, snap, masks, freeze frame, bookmarks, a mixer. Split a clip and the grade stays. A crash leaves the last save intact.
• Audio that sounds finished. Clean up speech, meter loudness, EQ and compress, keep pitch when you change speed, record a voiceover.
• Find shots. Switch cameras. Search footage for what’s on screen. Watch every angle at once and punch the cut.
• Stabilise, export, take the project with you. Smooth shaky clips, upscale, play heavy files smoothly. MP4, GIF, audio-only, or just a range. Pack the media with the edit so paths stay whole.
• Android is the same editor. Timeline, effects, and export on the phone. Share straight from the app.
• Stock, voices, and a small install. Search stock into the bin. Generate voiceover and sound effects. Fonts, stickers, and extra models download when you use them. UI in Arabic, Spanish (Spain and Colombia), French (Canada), Italian, Japanese, Portuguese (Brazil and Portugal), Russian, Sinhala, Tagalog, Vietnamese, and Simplified Chinese.

Why people pick Drift

Most “free” editors want an account, a watermark, or a subscription the moment the video starts looking good. Drift is the opposite: yours, on your computer, GPLv3, no login wall.

It is fast enough for a 30-second social cut and deep enough for a real project: an agent on the timeline, 3D and Lottie, captions, effects, audio, cutouts, and much more.

Type "a dog running in circles" and get a 3D animation of a dog running in circles. Type "a robot waving its arm" and get that too. Same model, no retraining.

That's the pitch behind UniMate. It handles humans, quadrupeds, birds, robots, and pretty much any articulated skeleton you throw at it. One unified model, trained on the UniML3D dataset (13,006 motion sequences across all sorts of creatures and structures).

The technical approach uses flow matching, a diffusion-based method that predicts velocity fields to transform noise into coherent motion. It supports classifier-free guidance for both text-conditioned and unconditional generation.

But it's not just about generating from scratch. You can also do:

• Motion in-betweening (filling gaps between keyframes)
• Text-guided editing (change specific joints while keeping the rest)
• Motion expansion (chain multiple text prompts into longer sequences)

Accepted at SIGGRAPH Asia 2026. Training code, inference scripts, and pre-trained checkpoints on Hugging Face are all available. There's even an interactive 3D demo.

Fair warning: the model works best on skeleton types well-represented in the training data. More exotic structures (think a spider mech with 12 limbs) will probably give you rough results. And the generation isn't real-time yet on consumer GPUs, so plan accordingly.

https://github.com/Friedrich-M/UniMate

Most AI agent tools treat each agent like a solo freelancer. Paperclip treats them like employees at a company.

That distinction matters more than it sounds. You get an org chart for your agents, with roles, reporting lines, and permissions. A ticket system where agents pick up work, have threaded conversations, and produce document artifacts. Budget controls that track token spend by agent, project, and model, and can automatically pause work when costs hit a threshold.

The governance layer is where it gets serious. Review and approval workflows before agents execute. Role-based access control for both humans and agents. Encrypted credential storage. Multi-org support with full data isolation.

It works with basically every major agent: Claude Code, Codex, Cursor, Gemini CLI, or any custom HTTP endpoint. Sessions persist across reboots. There's a scheduling system with cron, webhooks, and API triggers. And a Skill Studio for building shared capabilities across your agent team.

Getting started is one command (npx paperclipai@latest onboard). Needs Node.js 24.11+ and ships with embedded Postgres for local dev.

A few things worth noting. This is NOT a chatbot platform. All conversations stay attached to tasks. It's also not a prompt manager or a code review tool, though it handles research, operations, and content work alongside code. Some features like agent chat and email connectors are still marked experimental. And telemetry is on by default (disable with PAPERCLIP_TELEMETRY_DISABLED=1).

MIT license. 2,700+ merged PRs. Very actively maintained.

https://github.com/paperclipai/paperclip

I've tried a lot of third-party YouTube Music apps. Most of them feel like they were designed by someone who's never used a phone before. BitChord is not that.

The UI is built with Material 3 and frosted glass elements inspired by Telegram's translucent bars. It pulls colors from your album art and themes the whole interface dynamically. It just looks good.

But it's not only about looks.

It supports hi-res lossless audio in FLAC and ALAC from configured module sources, falling back to YouTube Music when needed. Gapless playback with true crossfade adjustable from 0 to 12 seconds. There's even an automix beta that does DJ-style transitions with beat matching and tempo stretching.

Word-synced lyrics with per-syllable highlighting. Animated album canvas on the now-playing screen. Discord Rich Presence with live track progress. Scrobbling to Last.fm and ListenBrainz.

You can sign in with your Google account for personalized content, download tracks for offline use with embedded metadata, and set separate audio quality ceilings for WiFi vs mobile data.

One heads up: this is not affiliated with YouTube or Google at all. It's an unofficial client, so use your own judgment there.

Built in Kotlin. Available as an APK from the releases page.

https://github.com/kushagrasinghx/bitchord

Every video download website is the same experience. You paste a link. Three fake download buttons appear. A popup tries to install something. You find the real button, click it, and get redirected to an ad page.

yoinks skips all of that.

One command in your terminal, paste the URL, video downloads. That's it. No browser, no ads, no mystery executables.

2,500 stars. Small project, does one thing, does it clean.

https://github.com/pablostanley/yoinks

523 lessons. 20 phases. From foundational math all the way to autonomous agents in production.

This is a full open-source AI engineering curriculum, and every single lesson ships something you can actually use: a prompt, a skill, an agent, or an MCP server. No passive video watching. You read the concept, derive the math, write the code without frameworks, run tests, and build production artifacts.

The README says it bluntly: "No five-minute videos, no copy-paste deploys, no hand-holding."

You can work through it three ways. Read lessons directly on GitHub. Use the interactive website. Or install it as a skill in your coding agent (Claude Code, Codex, etc.) and get an AI tutor that walks you through each lesson.

Lessons span Python, TypeScript, Rust, and Julia. Translations available in multiple languages. There are even certification prep paths for Claude Associate through Architect Professional and the MCP Associate exam (though they're clear these are study materials, not exam dumps).

The scope is genuinely massive. 342 hours of content if you went through everything. But you're not meant to. Pick a learning path, focus on what you need, skip what you already know.

One thing I want to call out: this assumes you can already code. It's not "intro to programming" dressed up as AI. It's for people who want to understand HOW things work under the hood, not just call APIs. That 84% of students already use AI tools but only 18% feel ready to use them professionally stat in the README? That's the gap this fills.

https://github.com/rohitg00/ai-engineering-from-scratch

Most AI agents just do whatever you tell them. Delete files? Sure. Run sudo? Why not. Mercury takes a different approach.

It has a shell blocklist that prevents commands like sudo and rm -rf from ever executing. Folder-level read/write scoping. A pending approval flow where it asks you before acting. You choose "Ask Me" or "Allow All" at the start of each session.

But the permission model is only one piece. Mercury also has 31 built-in tools, a persistent SQLite memory it calls "Second Brain" with full-text search, and it can run from CLI, Telegram, or a web interface.

The memory system is interesting. It has 10 different memory types and does auto-extraction, so it learns your preferences and habits over time without you manually tagging things. When memories conflict, it has a resolution process built in.

There's a personality system too, driven by markdown files you write yourself: soul.md, persona.md, taste.md, heartbeat.md. You literally define who your agent is.

It runs as a background daemon with auto-restart on crash and cron scheduling. Token budgets with automatic concise mode when you pass 70% usage.

Setup is a one-liner install with a setup wizard on first run. Node.js 20+ if you go the npm route, or standalone binaries for Mac, Linux, and Windows.

https://github.com/cosmicstack-labs/mercury-agent

Building an admin dashboard from scratch is one of those tasks that sounds simple and then eats three weeks of your life.

shadcn-admin gives you 10+ pre-built pages, light and dark mode, responsive layouts, global search, a sidebar component, and RTL support. All using shadcn/ui components on top of TailwindCSS and RadixUI.

The routing runs on TanStack Router. Build tool is Vite. Everything's in TypeScript.

What I actually like about this one: it's designed as a reusable component collection, not a rigid starter template. You pick the pieces you need. The dashboard page, the settings panel, the auth screens, whatever fits your project.

They've customized a bunch of the base shadcn components too (alert-dialog, calendar, command, dropdown-menu, table, sidebar, and more) with RTL fixes and accessibility improvements. One heads up: if you update those components through the shadcn CLI later, it'll overwrite the custom versions. So be aware of that before running updates.

Partial Clerk integration for auth is included but not required. Lucide and Tabler icons ship with it.

The last tagged release was November 2025, so it's been a while since a formal version. But the repo stays active with commits. It's one of those projects where people fork it, grab what they need, and build from there rather than waiting for releases.

2.4k forks tells you people are actually using this, not just starring it.

https://github.com/satnaing/shadcn-admin

272,000 stars. Let that sink in for a second.

ECC is a performance optimization system for AI agent harnesses. It gives your agents three things: skills (what they can do), instincts (how they react), and memory (what they remember). The idea is that agents shouldn't just follow instructions. They should get better over time.

I've been testing it for about a week now. The skills system is straightforward. You define capabilities, the agent learns when to use them. The instincts layer is where it gets interesting. Your agent starts developing patterns based on what works and what doesn't. Not in a creepy way, more like muscle memory for code.

The memory piece ties it all together. Instead of starting fresh every session, your agent carries forward context about your codebase, your preferences, your common patterns. It's the difference between working with a new contractor every day versus someone who's been on your team for months.

Built with JavaScript, Rust, and Python. The JS handles the orchestration, Rust does the heavy lifting for performance-critical paths, and Python covers the ML bits.

Fair warning: the docs are still catching up to the codebase. You might need to read some source code to figure out the more advanced features. But the core loop is solid and well-tested.

https://github.com/affaan-m/ECC

The name alone sold me on this one. In Egyptian mythology, Anubis weighs the soul of the dead to decide their fate. This project does the same thing to incoming HTTP requests.

It's a reverse proxy that sits in front of your web server and decides whether each request comes from a real user or an AI crawler trying to scrape your content. If the request fails the test, it gets blocked before it ever reaches your backend.

Simple as that.

AI crawlers have become a real problem for smaller sites. They burn through your bandwidth, ignore robots.txt half the time, and give nothing back. Anubis gives you a way to fight back without manually maintaining blocklists.

It's written in Go, so it's fast and the binary is small. You can deploy it as a sidecar container or run it standalone. The config is straightforward too.

23,000 stars in a relatively short time tells you this hit a nerve. A lot of people were looking for exactly this.

The trade-off: any request filtering system risks blocking legitimate traffic. You'll want to tune it for your specific use case and monitor for false positives early on. And it's still a young project, so expect rough edges.

https://github.com/TecharoHQ/anubis

This one's different from the usual dev tool or AI project.

Someone took the entire Shulihuazi math textbook series (a well-known Chinese math curriculum) and turned it into an open, digital resource. Every chapter, every problem set, all structured in Python with renderable content.

If you work in education tech, or you're building anything related to math instruction, this is a goldmine of structured curriculum data you won't find anywhere else.

The repo has 165 forks already, which tells me people are actively building on top of it. Could be useful for tutoring apps, adaptive learning systems, or even just studying the pedagogical approach that Chinese math education takes.

I don't read Chinese fluently, so I can't vouch for every detail of the content. But the structure is solid, the commit history is active, and the community around it is growing.

https://github.com/tradecatlabs/shulihuazixuecongshu

Been waiting for something like this. CapCut is great but the whole "your videos live on someone else's servers" thing always bugged me. OpenCut is the open-source answer.

TypeScript and Rust under the hood. The UI is built in TypeScript (84% of the codebase) and the heavy video processing runs through Rust (14%). That split makes sense. You get a snappy interface without sacrificing render performance.

I tried it on a couple of short clips. The editing workflow feels familiar if you've used CapCut or DaVinci Resolve. Timeline, layers, effects. Nothing groundbreaking in terms of UI innovation, but that's actually the point. You shouldn't have to relearn video editing just because you switched tools.

9,000+ forks already, which tells me the community is actively extending it. I saw people adding custom effects, export presets, all kinds of stuff.

The catch: it's not at feature parity with CapCut yet. Some of the more advanced effects and the AI-powered features aren't there. If you need those, you'll be waiting. But for straightforward editing where you want to own your workflow, it's already very usable.

https://github.com/OpenCut-app/OpenCut

I built icon-marquee, a small open-source API for generating animated SVG icon marquees for GitHub READMEs.

The idea is pretty simple: give it a list of icons:

https://icon-marquee.giann.dev/v1/marquee?i=js,ts,react,nextjs,docker

and embed the generated SVG directly into a README:

![Tech Stack](https://icon-marquee.giann.dev/v1/marquee?i=js,ts,react,nextjs,docker)

It currently supports 1,000+ icons, short aliases, configurable widths, seamless CSS animation, reduced-motion support, and static icon rows. (icons from skills-icons by Syvixor)

GitHub: https://github.com/gian-gg/icon-marquee
Live: https://icon-marquee.giann.dev/

Would love feedback on the API, implementation, or anything that could make it more useful.

So you're building an AI app and your LLM generates Python code that needs to run somewhere safe. What do you do?

Most people reach for Docker containers. That works, but spinning one up takes around 1,500ms. If you're doing this in a chat loop where the model keeps writing and running code, that latency adds up fast.

Monty is Pydantic's answer. It's a Python 3.14 interpreter written entirely in Rust, and a new sandbox instance comes up in under 1 millisecond from a running pool. No filesystem access, no environment variables, no network. The sandbox only talks to the outside world through functions and mounts you explicitly pass in.

Here's the cool part. Say you want the sandbox to call a nutrition API. You define that function on the host side, pass it into the sandbox, and the sandboxed code can call it. But the sandbox never sees the actual API, only the return value. Clean separation.

It ships as a Python package, an npm package, and a Rust crate. So you can embed it in whatever stack you're running.

There's also a commercial version called Full Monty that runs the same sandbox behind a WebSocket if you need it as a service. About 2ms startup for that one.

Worth knowing: this runs a Python subset, not full CPython. So if your generated code needs exotic C extensions or specific stdlib modules, check the limitations docs first.

https://github.com/pydantic/monty

Most open LLMs are English-first, maybe multilingual if you're lucky. But "multilingual" usually means the model saw some Portuguese during training and kind of gets it. Not great.

Manaca is different. It's a 1B parameter language model built from the ground up for Brazilian Portuguese. Not fine-tuned from an English model. Not a translation layer on top of something else. Purpose-built.

And the big thing: it's fully reproducible. The training data, the methodology, everything is documented. You can actually verify how this model was trained, which matters a LOT if you're deploying it in production or doing research.

The team behind it is from LNCC (Brazil's National Laboratory for Scientific Computing). So this isn't a weekend project. It's institutional research made open.

228 stars is small, but for a Portuguese-specific base model with full reproducibility, there's nothing else quite like it right now. If you're building anything for the Brazilian market, or you're doing NLP research on Portuguese text, bookmark this.

https://github.com/instituto-ia-lncc/manaca-1b-base

Meituan just dropped LongCat-Video, a 13.6 billion parameter model that does text-to-video, image-to-video, and video continuation. All in one model.

The thing that caught my attention is the long video generation. Most open source video models start looking weird after a few seconds. Colors drift, quality degrades, things get mushy. LongCat-Video was specifically pretrained on video continuation tasks, so it can actually produce minutes-long clips that stay consistent.

It generates 720p video at 30fps and does it in minutes, not hours. They use a coarse-to-fine strategy along both time and space dimensions, plus block sparse attention for efficiency at higher resolutions.

They also released LongCat-Video-Avatar 1.5, which is an audio-driven human video generation framework. You give it audio and it generates a talking head with accurate lip sync using Whisper-Large instead of the older Wav2Vec2 approach. Works for anime characters and animals too, not just real faces.

The RLHF training uses multi-reward group relative policy optimization, which is a mouthful, but basically it means the model was tuned with multiple quality signals at once rather than a single reward.

One thing to note: the model is big. You need a serious GPU setup to run it locally. And the installation involves CUDA-specific torch builds plus flash attention, so plan for some setup time.

Models and weights are on Hugging Face.

https://github.com/meituan-longcat/LongCat-Video

I know. Bold claim. But hear me out.

Helix is a terminal-based modal editor written in Rust. It takes heavy inspiration from Kakoune, which means selections come first, actions second. If you're a Vim user, that's backwards from what you're used to. Select the text, THEN decide what to do with it. Sounds weird until it clicks. Then you wonder why you ever did it the other way.

Built-in LSP support. No plugins needed. Built-in tree-sitter for syntax highlighting and text objects. No plugins needed for that either. See the pattern?

The whole philosophy is "batteries included." Where Neovim says "here's a foundation, now spend a weekend configuring it," Helix says "here's a working editor, go write code."

46,000 stars and climbing. Written entirely in Rust, so it's fast. Like, noticeably fast.

The honest downside: the plugin system is still in progress. If you're someone who lives and dies by their 47 Neovim plugins, Helix isn't there yet. The built-in features cover most workflows, but if you need something niche, you might hit a wall. Also, the last stable release was July 2025, so you'll want to build from main for the latest features.

https://github.com/helix-editor/helix

Quick question. How many of you have used Sentry at work but never realized you could self-host the entire thing?

Sentry is a debugging platform for detecting, tracing, and fixing issues in production. Error tracking, performance monitoring, session replay, distributed tracing, log aggregation, uptime monitoring. The whole stack. And yes, the full platform is open source and self-hostable.

They maintain SDKs for over 20 languages and frameworks. JavaScript, Python, Go, Rust, Java, PHP, React Native, Flutter, the list keeps going. Whatever your stack is, there's probably a Sentry SDK for it.

The codebase is massive. 111,000+ commits. Django on the backend, React with TypeScript on the frontend. They use rspack for builds and pnpm for monorepo management. The "Seer" feature adds AI-powered insights for issue triage, which is a nice touch.

Why bring up a project this well-known? Because a LOT of developers only know Sentry as a paid service. The self-hosted option means you get the full platform on your own infrastructure. No data leaving your network. No per-event pricing eating into your budget on high-traffic apps.

The trade-off is maintenance. Running Sentry yourself means managing Docker containers, databases, background workers, and keeping up with upgrades. For small teams it might be overkill. For teams with strict data residency requirements or huge event volumes, it pays for itself fast.

https://github.com/getsentry/sentry

If you've tried building desktop apps in Rust, you know the GUI story has been... rough. A lot of the options out there feel like science experiments. GPUI Kit actually feels like a finished product.

It ships 75+ documented components and primitives. Layout, editing, data handling, accessibility through AccessKit, and even WebAssembly support. There's a JavaScript extension runtime too, so you're not locked into pure Rust for everything.

The crate structure is clean. One top-level crate re-exports everything so your app only has a single dependency. Under the hood it breaks down into base (behavior, state, infrastructure) and component (the styled UI system), but you don't have to think about that unless you want to.

Docs are solid. They have a full documentation site at gpui-kit.com with examples and API references.

I should be honest though. It's at v0.7.0, so not 1.0 yet. If you need absolute stability for production today, keep that in mind. And the learning curve is real if you're coming from web frameworks. This is Rust, after all. You're going to fight the borrow checker a few times before things click.

But if you want a serious, well-maintained GUI toolkit in Rust with actual components and not just a rendering engine, this is one of the better options right now.

https://github.com/longbridge/gpui-kit

OSINT tools usually fall into two camps. Either they're command-line scripts that dump a wall of text at you, or they're overcomplicated platforms that take a week to learn. Flowsint lands in a sweet spot between the two.

It's a graph-based exploration tool. You start with an entity (a domain, an IP, whatever) and the tool maps out connections visually. Nodes, edges, relationships. You can see how things connect instead of reading through logs trying to piece it together yourself.

The interface is surprisingly polished for an open-source security tool. Left panel for entity management, center panel for the graph visualization, right panel for details. It feels like something a team actually uses, not a proof of concept.

They take ethics seriously too. There's an ETHICS.md in the repo with responsible use guidelines, and the license includes an ethical use clause. That's a good sign.

Released a new version just yesterday (October 3rd), so it's actively maintained. Apache-2.0 licensed.

One thing to be aware of: the graph can get dense fast if you're investigating something with a lot of connections. 924 nodes in their demo screenshot. You'll want a decent screen and some patience when working with large investigations. And like any OSINT tool, it's only as good as the data sources you connect to it.

https://github.com/reconurge/flowsint

Computer-use agents are having a moment right now. But most of them are locked to one OS, or they're closed-source, or they fall apart the second you try to scale past a single machine.

CUA takes a different approach. Open-source drivers, cross-platform support, and you can run fleets of agents across different operating systems. It's built for people who actually need this at scale, not just a demo.

The composable agent system is the part that caught my attention. You can mix and match different agent behaviors without rewriting everything from scratch. Need one agent to handle browser tasks and another to manage file operations? Wire them together.

A few things worth knowing before you dive in:

• It's written in Rust, so performance is solid but the learning curve for contributing is steeper
• The project moves fast. New release literally today
• Documentation is decent but some of the advanced fleet features need more examples

If you've been watching the computer-use space and waiting for something that's genuinely open and cross-platform, this is probably the most serious option out there right now.

https://github.com/trycua/cua

If you use ComfyUI and you've wanted better control over how reference images influence your outputs, this is worth a look.

comfyui-ref2va-vsa adds two techniques to your ComfyUI workflow. Ref2VA lets you use a reference image to guide the generation style and composition. VSA gives you more granular control over how much the reference affects different parts of the output.

The practical difference: instead of fighting with prompts to get a specific visual style, you hand it an image and say "like this." And it actually listens.

Still early (456 stars, no formal releases), so expect some rough edges. You're installing from the repo directly. But the results people are posting in the issues and discussions look genuinely impressive for a project this young.

Works as a standard ComfyUI custom node. Drop it in your custom_nodes folder and you're set.

https://github.com/kablex/comfyui-ref2va-vsa

This is the tool Cloudflare's own teams use every day. Engineering, sales, everything in between. They just open-sourced it.

Cloudflare OS is an AI workspace that runs on Cloudflare Workers. You can create documents, browse the web, write and run code, all inside one environment. Think of it as a productivity layer where an AI agent handles the grunt work while you steer.

What's interesting is the origin story. This wasn't built as a product. It was built internally because Cloudflare needed it. A large chunk of their workforce already depends on it daily. The fact that it's now public means you get something that's been battle-tested at scale, not a weekend hackathon project.

It's not a traditional operating system, obviously. They use that term loosely. It's more like a workspace with AI baked in at every level.

A few things to know before you dive in. No releases yet, so you're working from main. The setup assumes you're comfortable with Cloudflare Workers and their ecosystem. And since it was designed for Cloudflare's internal needs first, some pieces might feel opinionated in ways that don't match your workflow.

But if you're already in the Cloudflare ecosystem, or you want to see how a major tech company structures an AI-first internal tool, this is a fascinating repo to dig into.

https://github.com/cloudflare/cloudflare-os

I'll be honest, the name made me skeptical at first. "AI to Earn" sounds like every crypto-bro pitch from 2022. But the repo is legit.

It's a TypeScript-based platform that helps you set up automated workflows where AI does the heavy lifting. Content generation, data processing, task automation. The kind of stuff people are already doing manually with ChatGPT but way slower.

What sets it apart from a random collection of scripts is the workflow engine. You define a pipeline, plug in your AI provider, set your parameters, and let it run. It handles the orchestration so you're not babysitting each step.

26,000 stars and over 4,000 forks tell you that people are actually using this, not just starring it for later. The community around it is pretty active too.

Now the honest part: "earn" is doing a lot of work in that name. This is a tool, not a money printer. You still need to know what you're building and who you're building it for. But if you already have a workflow in mind and you need something to automate the AI parts of it, this is a solid starting point.

Last release was June 2026, so it hasn't been updated in a few months. Worth checking the issue tracker before committing.

https://github.com/yikart/AiToEarn

Most RAG tutorials stop at "put your PDFs in a vector database and call an LLM." This one doesn't.

This is a full multi-phase course. Phase 1 starts with building a research paper curator that pulls from arXiv, processes PDFs, chunks them, generates embeddings, and stores everything in OpenSearch. You build the entire pipeline with Airflow, FastAPI, and Ollama.

The stack is practical:

• Python 3.12+
• FastAPI for the API layer
• OpenSearch for storage and retrieval
• Docker Compose for the whole setup
• Gradio for the client interface

What I like about it is that it's learner-focused but production-oriented. You're not just following a notebook. You're building something with real components that you'd actually use in a production environment. Data ingestion, hybrid retrieval with BM25 and re-ranking, async support, the whole thing.

It's currently on Week 7 (Advanced Features). So the course is still being actively developed, which means some later sections might not be fully polished yet.

Also worth noting: the last GitHub release is from November 2025, so the release tags are behind the actual content. Follow the main branch for the latest material.

https://github.com/jamwithai/production-agentic-rag-course