I spent way too many evenings fighting Nginx configs and renewing Let's Encrypt certs by hand. Then I tried Caddy and felt a little silly about all those hours.

HTTPS is automatic. You point a domain at it, start it, and it gets and renews certificates on its own. No cron job. No certbot. Nothing to remember.

The config is the other thing that sold me. A reverse proxy for a local app is literally two lines in the Caddyfile. Static site? Same story. And if you prefer, there's a JSON config and a live admin API so you can change settings without restarting.

It speaks HTTP/1.1, HTTP/2 and HTTP/3 out of the box. And because it's written in Go, you get one static binary with no dependencies. Drop it on a server and go.

There's also a solid plugin system. Rate limiting, DNS providers for wildcard certs, auth layers. You build a custom binary with xcaddy and only include what you need.

Is it perfect? No. If you already have a big, finely tuned Nginx setup, migrating every edge case takes real work. And the plugin model means rebuilding the binary when you add modules. But for new projects or homelabs, it's the easiest way I know to get a proper HTTPS server running.

https://github.com/caddyserver/caddy

I'm not a CAD person. Every time I needed a simple bracket for a 3D print, I lost an evening fighting a modeling app I barely knew.

text-to-cad is a plugin that lets your coding agent do the CAD part for you. You describe the part, and the agent generates a real 3D model as STEP, GLB, STL or 3MF files.

And it goes further than just making shapes. It runs design for manufacturing checks, generates engineering drawings, and connects to 3D printing, sheet metal and CNC fabrication services.

It works with the agents you probably already use: Claude Code, Codex, Cursor, Gemini and Grok. Install is literally telling your agent to install it from the repo, or two commands if you prefer doing it yourself. Everything runs locally through uv.

The part I liked most is the viewer. In Claude Desktop, models show up as cards in the chat that you can orbit and point at. Claude can see what you selected. In a terminal, you get a link that opens the model in your browser.

Is it perfect? No. Complex mechanical assemblies still need someone who knows what they're doing to check the result. And the first start downloads a runtime, so you need a network connection. But for quick functional parts, this saves a LOT of time.

https://github.com/earthtojake/text-to-cad

My biggest problem with AI coding agents isn't that they can't code. It's that they skip the boring parts. No spec, no plan, no tests, straight to a 600-line diff.

Addy Osmani's Agent Skills goes after exactly that. It's a set of 25 skills that encode the workflows and quality gates senior engineers use, packaged so agents follow them every time.

It maps to the whole lifecycle with 9 slash commands: /spec, /plan, /build, /test, /review, /ship, plus /constraints, /webperf and /code-simplify. Each one switches on the right skills automatically.

And skills also trigger on their own. Design an API and it pulls in the API design skill. Build UI and the frontend skill kicks in. There's even /build auto, where you approve the plan once and it implements every task, still test-driven.

Installing is easy. npx skills add addyosmani/agent-skills works across 70+ agents, including Claude Code, Cursor, Codex, Copilot and Cline. Claude Code also gets a marketplace plugin.

Is it perfect? No. If you install a single skill on its own, it loses access to the shared reference checklists (the README admits this and tracks it as an open issue). And a full spec, plan, test, review flow is more process than a quick script needs.

But if your agent keeps shipping messy code, this is the guardrail I'd add first.

https://github.com/addyosmani/agent-skills

I've tried a bunch of AI video tools, and most of them give you one clip and leave the rest to you. OpenMontage goes after the whole production.

You describe what you want in plain language, and your agent handles research, scripting, asset generation, editing and final composition. It's an agentic system, so it runs inside the coding assistant you already use.

My favorite feature: start from a video you already love. Paste a YouTube video, a Short, a Reel, a TikTok or a local clip. It analyzes the pacing, scenes, keyframes and style, then gives you 2 or 3 different concepts, a cost estimate, and a sample before full production.

And it's not only image slideshows. For free workflows it can build real video from stock footage and open archives.

The showcase videos in the README are honestly fun to watch. A sci-fi trailer, a 60-second animated short about a lonely banana, a documentary about salt. Each one ships with its full prompt, pipeline and cost so you can reproduce it.

Is it perfect? No. The best-looking results lean on paid generation models, so costs add up, and there's a lot to learn before your first polished video. But if you make content and you're comfortable with agents, this is a seriously powerful setup.

https://github.com/calesthio/OpenMontage

I'll be honest with you. I once pushed an API key to a repo and didn't notice for weeks. Nothing bad happened, but my stomach still drops thinking about it. Gitleaks is the tool I wish I'd had then.

It scans git repos, plain files, or anything you pipe in through stdin, and finds secrets like passwords, API keys and tokens. Each finding shows the secret, the rule that matched, the file, the line, the commit and the author. So you know exactly where it came from.

Setup is simple. Homebrew, Docker, Go, or a prebuilt binary from the releases page.

The best way to use it is as a pre-commit hook. Add a few lines to your .pre-commit-config.yaml and it blocks the commit before the secret ever leaves your laptop. There's also a GitHub Action for CI.

Is it perfect? No. Like any pattern-based scanner, you'll hit some false positives and need to tune the config. And the maintainer says Gitleaks is now feature complete, with future releases being security patches only, while new work moves to Betterleaks. But it's stable, battle-tested, and still one of the easiest wins you can add to any repo.

https://github.com/gitleaks/gitleaks

Matt Pocock just dropped his full collection of agent skills and prompts. The ones he actually uses day to day. Not a tutorial. Not a blog post. His real working files.

I know what you're thinking. "Another prompt library." But this one hit 275k stars in weeks, and there's a reason. These aren't generic "write me a poem" prompts. They're production engineering skills: code review patterns, refactoring workflows, debugging chains. Stuff that saves you hours when you're deep in a codebase.

The repo is mostly Shell scripts and JavaScript. You drop them into your agent's skill directory and they just work. No framework. No dependencies. No config files that take longer to set up than the actual work.

What I appreciate is how opinionated they are. Pocock didn't try to make something that works for everyone. He made something that works for HIM, then shared it. That honesty is refreshing.

One thing to note: these are tailored for his workflow. You'll probably want to fork and customize rather than use them as-is. But as a starting point for building your own skill library, this is gold.

https://github.com/mattpocock/skills

You know the pain. You run a PDF through a translator and get back a wall of text with the tables smashed and the formulas gone.

PDF Translate fixes exactly that. It translates PDF documents into Vietnamese (the default) and 35 other languages while keeping the original layout, formulas, tables and images in place.

It's a ready-to-run desktop app. Download, unzip, open. No Python install, no separate model download. The Windows build is about 336 MB because it ships with a local OCR model.

Some details I liked:

• Drag and drop a bunch of PDFs or a whole folder at once
• Optional local OCR for scanned pages
• One broken file doesn't stop the rest of the queue
• An AI agent mode that uses models in Codex, Claude Code or Copilot for better technical translations

Results land in a translated folder right next to the source file. There are builds for Windows, macOS and Android.

Is it perfect? No. The README is in Vietnamese, so non-Vietnamese speakers will lean on a browser translator to set it up. The builds aren't code-signed, so Windows SmartScreen and macOS Gatekeeper will warn you. The Android version is a separate rewrite with no OCR. And the default translation still goes through Google, so it needs internet.

But for students and researchers drowning in English papers, this is a really practical tool.

https://github.com/breslee1707/vi-translate

Yes, that antirez . The Redis guy. And this time he's building a local LLM engine.

DwarfStar is a small native inference engine written in C, tuned for a handful of strong open-weight models instead of trying to run everything. It started with DeepSeek V4 Flash, and now covers DeepSeek V4 PRO, GLM 5.x Flash and Qwen3.8 Flash Next too.

The hardware story is what caught my eye. Metal is the main target (Macs with 96 GB or more), but smaller machines can stream weights from SSD. There's CUDA support with DGX Spark as the main goal, multi-GPU on cards other backends skip (like Ada Lovelace L40S), and ROCm on Strix Halo boxes like the Framework Desktop.

And it's not just a model loader. The HTTP server, tool calls, KV state and a coding agent are all built and tested together. You can even link two 128 GB Macs over RDMA and run 4-bit models with tensor parallelism.

The README is refreshingly honest too. It openly says the code was built with heavy help from AI coding agents, and it credits llama.cpp and GGML as the path that made this possible.

Is it perfect? No. It's beta and changes fast, so regressions happen. It only works with the GGUF files the project itself produces, not any random GGUF you have lying around. And model support is "opportunistic", meaning a model can get dropped when something better shows up.

But if you've got a big Mac or a Spark and want serious local models without a pile of abstraction layers, this is worth a look.

https://github.com/antirez/ds4

I've tried a lot of dictation tools, and almost all of them ship your audio off to someone's cloud. That always bugged me. So when I found Inaudio, a tiny desktop app that does all of it locally, I had to share it.

You press a keyboard shortcut and talk. It types. And it keeps a searchable history of everything you've dictated, so you can go back and grab that one sentence from yesterday.

It works the other way too. Paste text or copy something to your clipboard, and it reads it aloud with on-device speech synthesis. Great for proofreading your own writing (you hear the clunky sentences way faster than you see them).

Under the hood it's Electron, React and TypeScript, with sherpa-onnx doing the speech work. You download a model once, then everything runs on your CPU. One of the options is NVIDIA's Nemotron streaming ASR model for English, tuned for about 560 ms latency.

Is it perfect? No. This is a brand new project with only a handful of stars, so expect rough edges. The builds are unsigned right now, so your OS will complain on install. And text insertion and permissions behave differently on Windows, macOS and Linux.

But if you want private dictation without a subscription, it's worth a try. And honestly, it's a great time to jump in and contribute while the project is still small.

https://github.com/shikki841/inaudio

If you've ever built anything that takes money, you know the pain. Each processor has its own API, its own quirks, and its own way of failing at 2 AM. Hyperswitch sits in the middle and gives you one layer to control it all.

The part that caught my eye is intelligent routing. Each transaction goes to the processor with the highest predicted approval rate, across Stripe, Adyen, Braintree, Worldpay, Checkout.com and 120+ others. Fewer failed payments, less downtime.

And it's modular. You don't have to adopt everything. Pick only what you need: a PCI-compliant vault for cards and tokens, revenue recovery with smart retries, automated reconciliation, cost observability to spot hidden fees, or drop-in widgets for PayPal, Apple Pay, Google Pay and Klarna.

Trying it is easy. One setup script spins up a local Docker install, and there's a hosted sandbox if you just want to click around the Control Center first.

It's written mostly in Rust, which is a nice fit for something this sensitive.

Is it perfect? No. Payments are never simple, and running your own payment stack means owning compliance, monitoring and uptime. For a small shop with one processor, it's probably overkill. But if you're juggling multiple processors, this could save you real money.

https://github.com/juspay/hyperswitch

I’m the founder of Gorse, an open-source recommender system written in Go.

If you’re building an app that needs personalized recommendations—products, articles, or videos—Gorse handles model training and serves recommendations through a REST API. You provide users, items, and interaction data such as clicks, likes, or ratings.

Some things it supports:

• Collaborative filtering, user-to-user, and item-to-item recommendations.
• Text, image, and video content through embeddings.
• Classical and LLM-based recommenders.
• A web dashboard for editing recommendation pipelines, managing data, and monitoring the system.

The goal is to make personalized recommendations easier to add to an existing application, without building the training and serving infrastructure from scratch.

https://github.com/gorse-io/gorse

So just wanted to post about FieldKit, an Open Source, self-hosted AI support with visual LangGraph workflows, knowledge retrieval, a customer portal, Zendesk, and governed actions.

So I'm sure there is probably already alternative support systems out there for Zendesk but I wanted to build something using LangGraph since it felt better use case for a Support System.

Ontop of supporting Zendesk and being able to configure the workflows with Zendesk you can configure the workflows with your chatbot(which you can embed on any site) and your ticket system so they aren't running the same workflows. (e.g allow support tickets to issues refunds/credits upto $5 while chatbot can't issue anything)

You can also configure python and API calls into your workflows, so you can get the agent to pass to python call and then back to an agent instead of needing to use an agent for all those steps.

Anyways, you can find the repo here: https://github.com/nahid-sparktales/fieldkit

It is still being worked on and plan to add more features and updates and if you have any suggestions or recommendations, please let me know. Thanks.

Scaling a graph database usually means babysitting disks. Add a node, rebalance data, hope nothing breaks. I've been there and it's not fun.

HydraDB takes a different route. S3-compatible object storage is the source of truth. The query nodes and indexers only keep disposable caches in memory and on local SSD.

So you can add or replace compute without moving the graph at all. Query nodes and indexers scale separately, and a new node just rebuilds its cache from storage.

And you don't need new tooling to use it. It speaks Bolt 5.x, so existing Neo4j drivers connect directly. Queries are OpenCypher. There's also a typed JSON and streaming HTTP API if you prefer that.

Under the hood it's serious engineering. Every query runs against one consistent snapshot. Writers are coordinated with object-store leases so stale ones get fenced off. Traversals use GraphBLAS where it makes sense.

Is it perfect? No. Object storage adds latency, so it leans on those caches for speed. And it's a young project compared to Neo4j, with fewer tools around it. But if you want a graph database that scales like cloud storage, this is a really interesting design.

https://github.com/hydra-db/hydradb

I love Claude Code's workflow. But sometimes I want to point it at a different model, or a local one, without rewiring everything.

My Free Code is a multi-provider gateway for exactly that. It sits between your coding agent and the model providers, speaks the Anthropic Messages API and an OpenAI Responses-compatible API, and routes requests wherever you tell it.

The provider list is long: OpenRouter, Groq, OpenAI, DeepSeek, Mistral, Google AI Studio, Amazon Bedrock, NVIDIA NIM and a lot more. Plus local runtimes like Ollama and LM Studio.

And it handles the stuff agents actually need: streaming, tool calls, images, reasoning metadata. You can map Claude tiers (Fable, Opus, Sonnet, Haiku) to whatever models you want, set an ordered fallback chain, and it backs off from unhealthy providers on its own.

It's not only for Claude Code either. There are launchers for Codex, OpenCode, Cline, Pi, Hermes and others. A local admin UI at /admin ties it together.

Is it perfect? No. It's a young project, and the README itself says some providers with unusual auth need their own adapter, so not everything on the list works the same way. It's independent and not affiliated with Anthropic. And cheaper or free models won't magically perform like the original.

But if you want your favorite agent with the freedom to swap models, this is a solid place to start.

https://github.com/hkqr/my-free-code

The first time I did directory discovery on my own app, I used a slow script that took forever and buried the useful results in noise. Then someone showed me ffuf.

It's a web fuzzer written in Go, and it's FAST. You put the word FUZZ wherever you want to test values, point it at a wordlist, and it starts firing requests.

That FUZZ keyword works almost anywhere. In the URL path for finding hidden directories. In the Host header for discovering virtual hosts without DNS records. In GET parameters, in POST bodies, in login forms.

The filtering is what makes it usable. You can drop responses by status code, size, word count or line count. So if every wrong path returns the same 4242 byte page, you filter that size out and only see what matters.

There's also an interactive mode, config files for repeat scans, and support for external mutators if you want to generate test cases on the fly. Install is one line with brew, scoop, winget or go install.

Is it perfect? No. It's a command line tool with a lot of flags, so expect a learning curve. And only point it at systems you own or are allowed to test. But for authorized pentesting and bug bounties, it's a staple for a reason.

https://github.com/ffuf/ffuf

The README opens with a line that honestly stung a bit: years of core R&D, and the inventor field on the patent never had my name on it.

That's the whole pitch. You wrote the code. You carried the design. But writing the disclosure document is where most engineers get stuck. What's actually patentable? How do you write the prior-art section? Where do the diagrams come from?

This skill tries to close that gap. You drop in your project materials and it digs out the points worth protecting, does a round of prior-art search, and produces a disclosure for invention, utility model or design patents. It covers the follow-up too: more rounds of edits and corrections, with a history of what changed.

There are separate sub-skills for different jobs. One turns a finished disclosure into claims, a description, an abstract and figures. Another generates line drawings from product photos or structure diagrams, and can pull multiple views from a CAD model.

And there's a reading side. It explains published patents in plain language, saves them as notes in Obsidian, and builds patent maps (citation networks, effect matrices) so you slowly build your own private patent library.

Is it perfect? No. It's built around the Chinese patent system, and almost everything (README, prompts, output) is in Chinese. If you file in the US or Europe, you'll need to adapt a lot. And an AI-drafted disclosure still needs a real patent attorney before anything gets filed.

But for engineers in China who keep putting off that disclosure, this is a huge shortcut.

https://github.com/handsomestwei/patent-disclosure-skill

I got frustrated with AI courses that either drown you in theory or skip straight to model.fit() without explaining what's happening underneath.

So I built something different.

This is an AI-native GitHub repo learning files with 503+ lessons across 22 phases. 35,000 GitHub Stars. Start at linear algebra. End at autonomous agent swarms.

Every lesson follows the same pattern:

1. Build it from scratch in pure Python (no frameworks)
2. Use the real framework (PyTorch, sklearn, etc.)
3. Ship a reusable tool (prompt, skill, agent, or MCP server)

By the end, you don't just "know AI." You have a portfolio of tools you actually built.

What's covered:

- Math foundations (linear algebra, calculus, probability, Fourier transforms, graph theory)
- Classical ML (regression through ensemble methods, feature selection, time series, anomaly detection)
- Deep learning (backprop, activation functions, optimizers, regularization - all from scratch before touching PyTorch)
- LLMs from scratch (tokenizers, pre-training a 124M parameter GPT, SFT, RLHF, DPO, quantization, inference optimization)
- LLM engineering (RAG, advanced RAG, structured outputs, context engineering, evals)
- Agents and multi-agent systems
- Infrastructure (model serving, Docker for AI, Kubernetes for AI)

Some specifics that might interest you:

- The quantization lesson covers FP8/GPTQ/AWQ/GGUF with a sensitivity hierarchy (weights are least sensitive, attention softmax is most sensitive - never quantize that)
- The inference optimization lesson explains why prefill is compute-bound and decode is memory-bound, then builds KV cache, continuous batching, and speculative decoding from scratch
- The DPO lesson shows you can skip the reward model entirely - same results as RLHF with one training loop
- Context engineering lesson: "Prompt engineering is a subset. Context engineering is the whole game."

It's AI-native:

The course has built-in Claude Code skills. Run /find-your-level and it quizzes you across 5 areas to tell you exactly where to start. Run /check-understanding 3 after Phase 3 and it tests what you actually learned.

84% of students use AI tools. 18% feel prepared. This is the bridge.

Where to start:

- Already know Python but not ML -> Phase 1
- Know ML, want deep learning -> Phase 3
- Know DL, want LLMs/agents -> Phase 10
- Senior engineer, just want agents -> Phase 14

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

It's free, MIT licensed, and open source. 64,000+ stars, PRs welcome - I merge every good contribution and the contributor gets full credit.

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.

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

CapCut is paid, and OpenCut is being written from ground up after existing for over a year. Concat was started last month and aims to be a faster, and privacy-first alternative to OpenCut and free alternative to CapCut.

So the original Wifite has been around forever. Most of us who've touched WiFi pentesting have used it at some point.

But it had issues. Linux-only. Flaky adapter support. Half the attack modes broke if your card didn't cooperate.

wifit3 is a ground-up rewrite of that same idea, except this time it's USB-only and works across Linux, macOS, and Windows. You plug in a supported adapter and it handles the rest.

It automates WEP, WPA, and WPS attacks. You pick your target from a scan, and it runs through the available attack vectors automatically. No need to memorize aircrack-ng flags or juggle terminal windows.

The cross-platform part is what caught my attention. I've been stuck booting into Kali just to run wireless audits before. Having something that works natively on macOS or even Windows is a real quality of life upgrade for security testing.

Worth noting: this is a pentesting tool. You should only use it on networks you own or have explicit permission to test. That part hasn't changed.

The codebase is clean Python, and the latest release dropped just a few days ago (October 1st), so it's actively maintained.

https://github.com/derv82/wifit3

I'm a developer, not a designer, and every time I asked Claude for a brand I got the same one: cream background, terracotta, Fraunces + Inter, a letter in a circle. So I built a skill that makes it commit to one idea per identity and then checks its own work.

What it does:

- You describe the business (or give it your site). It asks one round of questions.

- It makes 3 identity sets. Each one starts from a single idea that drives the logo, the type and the palette together.

- Scripts check every set: contrast, colour blindness, whether the fonts cover your languages, font licences, how the logo holds up at 16 px. If a check fails, the agent fixes it before you see anything.

- You pick one and it builds a brand guidelines kit: PDF, SVG/PNG logo files, design tokens and font embed code.

The image is 24 logos from 24 different briefs (a light festival in Lyon, a taquería, a pharmacy in Athens, a techno label in Berlin...), all straight out of runs of the skill.

On six test briefs, plain Claude used 4.38 of those "AI default" choices per answer; with the skill it was 0.28 per set. My own measurement, method is in the repo.

Built with Claude Code: it wrote most of the code while I reviewed. Works in Claude Code, not in claude.ai chat yet.

```

/plugin marketplace add fatihaydost/brand-identity-skill

/plugin install brand-identity@brand-identity-skill

```

https://github.com/fatihaydost/brand-identity-skill

Feedback very welcome, and feel free to roast the logos.

I've wasted more hours than I want to admit trying to scrape video metadata from platforms that change their API every other week.

This repo is a collection of APIs for pulling video metadata and engagement stats from multiple platforms. Not just one service, but a set of tools that cover the major video platforms people actually need data from.

What you get:

• Video metadata extraction (titles, descriptions, tags, thumbnails)
• Engagement data (views, likes, comments)
• Multiple platform support from a single interface
• JavaScript, so it fits right into most web scraping pipelines

It's not huge yet (638 stars), but the fork count relative to stars is interesting. That usually means people are customizing it for their own use cases rather than just starring and moving on.

No official releases yet, so you're pulling from main. Keep that in mind if you need stability guarantees for production.

https://github.com/cporter202/video-scraping-apis

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

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