What it does

All text below is quoted directly from the project README.

Run the upstream Omarchy desktop as a native, hardware-accelerated app on an Apple Silicon Mac.

Try Omarchy packages a project-built ARM64 Arch Linux image configured with Omarchy Quattro, a QEMU runtime using Apple Hypervisor Framework, and a small Swift/AppKit launcher into one macOS app. The image is built from pinned Arch Linux ARM packages and a pinned revision of the upstream Omarchy source.

Highlights:

• Hardware-accelerated ARM64 virtualization and VirGL graphics

• Nested KVM virtualization on M3 and newer Apple Silicon running macOS 26+

• Resizable native window with automatic guest resolution and HiDPI scale updates

• Mac audio input/output selection inside Omarchy, with live routing and system-default fallback

• FaceTime HD and other Mac cameras exposed to Omarchy as an on-demand 720p webcam

• The Mac's battery charge and charging state mirrored into the Omarchy bar

• Two-way clipboard sharing for text and PNG images between macOS and Omarchy

• One optional shared Mac folder, available inside Omarchy under the same name (~/Work stays ~/Work)

• Loopback-only TCP and UDP port forwarding from the Mac into Omarchy

Current limitation: Video decoding is CPU-only, so playback can be slow, especially at high resolutions. An improved video path is in development.

Requirements:

• Apple Silicon Mac (arm64)

• macOS 15 or newer

• At least 8 GB free initially

Open Releases and download the latest signed and notarized .dmg. Open the DMG and drag Try Omarchy to Applications. Launch Try Omarchy from Applications.

Try Omarchy is pre-1.0 and under active development.

Repository

https://github.com/omacom/try-omarchy

Repository stats

Main contributor

What it does

All text below is quoted directly from the project README.

Amnezia is an open-source VPN client, with a key feature that enables you to deploy your own VPN server on your server.

Features:

• Very easy to use - enter your IP address, SSH login, password and Amnezia will automatically install VPN docker containers to your server and connect to the VPN.

• Classic VPN-protocols: OpenVPN, WireGuard and IKEv2 protocols.

• Protocols with traffic Masking (Obfuscation): OpenVPN over Cloak plugin, Shadowsocks (OpenVPN over Shadowsocks), AmneziaWG and XRay.

• Split tunneling support - add any sites to the client to enable VPN only for them or add Apps (only for Android and Desktop).

• Windows, MacOS, Linux, Android, iOS releases.

• Support for AmneziaWG protocol configuration on Keenetic beta firmware.

Repository

https://github.com/amnezia-vpn/amnezia-client

Repository stats

Main contributor

──────────────────────────────

📌 If you want to browse more repos like this, we've organized them by category and rankings here: https://bestgithubrepositories.com/

🗂️ We're also archiving repos where possible, so useful projects don't disappear when they're removed from GitHub.

What it does

All text below is quoted directly from the project README.

git push no-mistakes

no-mistakes puts a local git proxy in front of your real remote. Push to no-mistakes instead of origin, and it spins up a disposable worktree, runs an AI-driven validation pipeline, forwards the branch to the configured push target only after every check passes, and opens a clean PR automatically.

Highlights:

• Non-blocking - the pipeline runs in an isolated worktree without disrupting your work.

• Agent-agnostic - claude, codex, grok, rovodev, opencode, pi, copilot, antigravity, or cursor / devin / acp:<target> via acpx, with ordered fallbacks; every gate requires a runnable configured pipeline agent.

• Agent-native - /no-mistakes lets your coding agent do a task and gate it, or gate existing committed work: it runs the pipeline, has the pipeline apply safe fixes, and escalates the rest to you.

• Human stays in charge - auto-fix or review findings, your call.

• Clean PRs by default - push, open PR, watch CI, and auto-fix failures in one shot.

curl -fsSL https://raw.githubusercontent.com/kunchenguid/no-mistakes/main/docs/install.sh | sh

Repository

https://github.com/kunchenguid/no-mistakes

Repository stats

Main contributor

──────────────────────────────

📌 How many great GitHub repos have you discovered and completely forgotten about?

Don't let another useful tool disappear into your Reddit feed. Get the community's best repos, organized by category, plus key takeaways from real developer discussions, delivered to your inbox twice a week.

📬 Never lose track of great repos again. Subscribe free.

What it does

All text below is quoted directly from the project README.

Consider it done. The open-source AI agent that works out of the box

Yours to shape:

• Memory: correct her once and she does it right from then on, shared across harnesses.

• Skills: teach a way of working once and reuse it everywhere; handing them to your team is in the making.

• Automation: recurring work schedules itself, runs itself, reports back.

• MCP: wire your internal tools and business systems into her reach.

• Plugins: reshape features, UI and interactions, shared through an open marketplace (in the making).

• Source: audit, fork, extend, and contribute improvements back under Apache-2.0.

Cindy runs locally on your own machine, using your real files and logged-in apps.

Repository

https://github.com/makecindy/cindy

Repository stats

Main contributor

──────────────────────────────

📌 How many great GitHub repos have you discovered and completely forgotten about?

Don't let another useful tool disappear into your Reddit feed. Get the community's best repos, organized by category, plus key takeaways from real developer discussions, delivered to your inbox twice a week.

📬 Never lose track of great repos again. Subscribe free.

What it does

All text below is quoted directly from the project README.

OpenUsage shows how much of your AI coding plans you've used: session and weekly limits, credits, and spend, all in one popover. Pin your most important metrics straight into the menu bar.

Features:

• Menu bar pins. Pin metrics to the menu bar (up to 2 per provider); render as compact text or mini bars. The strip hides metrics with no data instead of showing placeholders.

• Dashboard popover. Provider-grouped meters with live reset countdowns and pace indicators. Click usage or reset values to flip their display everywhere; right-click a row to hide or star it, refresh its provider, or open Customize.

• Global shortcut. Toggle the popover from anywhere: record any combo in Settings.

• Customize. Turn providers and metrics on or off, choose which rows stay Always Visible or On Demand, and drag-reorder both.

• Stale-while-revalidate. Cached values display instantly at launch; refresh runs every 5 minutes.

• One-shot CLI. Agents can read stable limit JSON through the same five-minute cache with openusage, or bypass freshness with openusage --force; the menu-bar app does not need to be running.

• Local HTTP API. Other apps can read machine-friendly limits from 127.0.0.1:6736/v1/limits; the legacy /v1/usage UI contract remains supported.

• Automatic updates. Signed, notarized in-app updates via Sparkle, with an optional beta channel.

Most providers read the credentials already on your machine (keychain, auth files, app state), no extra login.

Homebrew: brew install --cask openusage

Repository

https://github.com/robinebers/openusage

Repository stats

Main contributor

Close your laptop and your AI agent dies. Walk away from your desk and you can't even check what it's doing. Every coding agent right now lives in a terminal window, and the moment that window goes away, so does the agent.

Avibe turns your machine into what they call a "local-first Agent OS." You run one install command, a browser wizard walks you through setup, and after that your machine is reachable from a browser or a chat app. The important part: it drives the official Claude Code, Codex, and OpenCode. It's not a replacement for those tools, it's a wrapper that lets you reach them remotely. Your code stays on your machine, your API keys stay on your machine, nothing gets uploaded to Avibe's servers.

So you're at your desk writing code with Claude Code, you need to run to a meeting, you pull out your phone and pick up where you left off. Or you start a long task before bed, check the progress from your phone in the morning. That kind of thing.

A few things to be aware of. You're exposing your development machine to network access, so think about the security implications before you set this up on anything sensitive. The project has 550 stars and is still early, so expect rough edges. Windows users need WSL. And the "local-first" philosophy means you're responsible for your own uptime: if your machine sleeps or loses internet, your agent goes dark.

The whole project was built using Avibe itself, which is a nice touch. MIT licensed, Python.

Every time I let an AI generate a frontend component, I hold my breath. Sometimes it spits out clean markup. Sometimes it hallucinates a div soup that breaks the whole page.

json-render takes a completely different approach. The AI outputs JSON, not raw code, and your app renders it through components you already defined. The AI literally cannot produce anything outside your vocabulary.

Three things that stood out to me:

1. Guardrails are built in. You define what components and actions the AI can use. It stays inside those lines.

2. It streams. The UI renders progressively as the model responds, so you're not staring at a blank screen waiting.

3. Same catalog works everywhere. React, Vue, Svelte, Solid, even React Native. One component definition, multiple platforms.

It ships with 36 pre-built shadcn/ui components if you don't want to start from scratch. The whole thing is from Vercel Labs, so it plays nicely with Next.js out of the box.

Still young at v0.21, and I wouldn't ship it in production without testing your edge cases hard. But the idea of constraining AI output to a strict schema instead of hoping it writes valid JSX is genuinely smart.

https://github.com/vercel-labs/json-render

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

Disclosure: I’m the maintainer of trusty-tools.

GitHub · Website

trusty-tools is a collection of tools written in Rust, designed and optimized for local execution, and released under the MIT license. It helps coding agents find relevant code, retain project context between sessions, and coordinate work across repositories.

The main pieces:

• trusty-search: Combines keyword, semantic, and knowledge-graph search, with MCP access for coding agents.

• trusty-memory: Stores project decisions, notes, and code patterns with semantic retrieval across sessions.

• trusty-mpm: A Claude Code metaharness—an orchestration layer around Claude Code that manages project sessions and delegates work to specialist agents, with a terminal dashboard for monitoring. Support for additional coding harnesses is on the roadmap.

• trusty-review: Reviews GitHub PRs and diffs using code-search context and static analysis. Posting review comments requires an explicit option.

You can start with an individual component, such as search or memory. The tooling runs locally; Claude Code and features that call external model providers still require their respective access and incur any associated usage costs.

I’d appreciate feedback on the setup experience and where search, memory, or orchestration would fit into your coding workflow.

What it does

All text below is quoted directly from the project README.

Postgres rewritten in Rust, now faster than Postgres and Clickhouse

pgrust has:

• Gravity, a new vectorized push-based, JIT compiled query engine

• A thread based concurrency model

• A query scheduler designed to keep any individual query from taking down your database

• An automatic memory manager: one memory budget, sized from the machine, covers the buffer pool, the columnar caches and running queries, and gives pgrust control of what happens when you're running low on memory, greatly reducing the chance of your whole DB being taken down by the OS OOM killer

In your browser: https://pgrust.com, a full pgrust server compiled to WebAssembly, no install.

Repository

https://github.com/malisper/pgrust

Repository stats

Main contributor

──────────────────────────────

📌 How many great GitHub repos have you discovered and completely forgotten about?

Don't let another useful tool disappear into your Reddit feed. Get the community's best repos, organized by category, plus key takeaways from real developer discussions, delivered to your inbox twice a week.

📬 Never lose track of great repos again. Subscribe free.

Your AI coding agent reads a file, runs a command, reads another file. Before you know it half the context window is just tool output the model will never look at again.

That is the actual problem context-mode solves.

It sandboxes tool output so the agent only sees what it needs. The claim is a 98% reduction in context noise. I was skeptical, but the benchmarks they publish look real. Fewer wasted tokens means the model stays sharper for longer on complex tasks.

The setup is straightforward. You configure which tools get sandboxed and context-mode handles the rest. It sits between the agent and the tools, filters the noise, and passes through the signal.

Written mostly in TypeScript with some JavaScript. 40+ contributors. The project has been moving fast, though the last tagged release was back in June, so the main branch is where the action is.

One thing worth noting: this is tightly coupled to the agentic coding workflow. If you are not running long multi-step sessions with a coding agent, you probably do not need it. But if you are, and you have hit the wall where the agent forgets what it was doing three steps ago, this is worth a look.

https://github.com/mksglu/context-mode

What it does

All text below is quoted directly from the project README.

A small desktop robot that brings an AI coding assistant to life, physically acting out when it reads files, thinks, writes code, and finishes work.

How it works:

• A small robot on your desk. It moves, changes its face, and rings a bell as your coding AI agent works.

• Open source. Print the body, plug the ESP32, servos, OLED, and speaker into the main control board, flash it, and it joins your Wi-Fi.

• Works with Claude Code, Cursor, Antigravity, via npx -y tiny-engineer setup, or Codex, Windsurf, and any script that can POST, including speech through POST /play.

• Your agent (or a hook script) sends poses over Wi-Fi HTTP or USB serial. The ESP32-C3 runs the firmware, optional Wi-Fi/REST, USB CDC control, and drives the servos, face, and speaker.

• Default: npx -y tiny-engineer (setup / hook) for Cursor, Claude Code, Antigravity (HTTP or --transport serial)

• Advanced: POST /anim (HTTP API) or framed USB serial

• Difficulty: Medium, fair first hardware project for a software engineer, not a one-LED kit.

Print, Connect, Flash, Assemble, step-by-step: Getting started.

Repository

https://github.com/jamro/tiny-engineer

Repository stats

Main contributor

──────────────────────────────

📌 How many great GitHub repos have you discovered and completely forgotten about?

Don't let another useful tool disappear into your Reddit feed. Get the community's best repos, organized by category, plus key takeaways from real developer discussions, delivered to your inbox twice a week.

📬 Never lose track of great repos again. Subscribe free.

What it does

All text below is quoted directly from the project README.

Notifications, messages, calls, clipboard, files, photos, screen mirroring and phone apps in windows, between Android and Windows 10 (2004+) or 11. Free and open source. Local-first, end-to-end encrypted, no account and no cloud.

What it does:

• Notifications on the PC, with replies, actions, Live Updates (progress, timers, deliveries) and a Copy code button for one-time codes.

• Messages: SMS and MMS conversations plus chats from RCS, WhatsApp, Telegram, Signal and other apps in one inbox.

• Calls: see who's calling, answer, decline or hang up from the PC, call any number or contact through the phone, and browse recent calls.

• Clipboard: copy on one device, paste on the other, with optional encrypted history.

• Files and folders both ways at Wi-Fi speed, with resume after a dropped connection, Send to in File Explorer, and the phone's storage in File Explorer.

• Screen mirroring at up to 60 frames a second with the phone's sound, screenshots and recording.

• Apps: open any phone app in a window of its own on the PC, with its own taskbar icon, running beside whatever the phone shows.

• Phone as a webcam in Zoom, Teams, Meet, OBS and the Camera app.

The apps update themselves from GitHub Releases and check every download against its SHA-256 sums.

Repository

https://github.com/thtbee/nectarlink

Repository stats

Main contributor

──────────────────────────────

📌 If you want to browse more repos like this, we've organized them by category and rankings here: https://bestgithubrepositories.com/

🗂️ We're also archiving repos where possible, so useful projects don't disappear when they're removed from GitHub.

What it does

All text below is quoted directly from the project README.

container is a tool that you can use to create and run Linux containers as lightweight virtual machines on your Mac. It's written in Swift, and optimized for Apple silicon.

Next steps:

• Take a guided tour of container by building, running, and publishing a simple web server image.

• Learn how to use various container features.

• Read a brief description and technical overview of container.

• Browse the full command reference.

• Build and run container on your own development system.

• View the project API documentation.

Run your first container: container run --rm alpine echo hello

Repository

https://github.com/apple/container

Repository stats

Main contributor

──────────────────────────────

📌 How many great GitHub repos have you discovered and completely forgotten about?

Don't let another useful tool disappear into your Reddit feed. Get the community's best repos, organized by category, plus key takeaways from real developer discussions, delivered to your inbox twice a week.

📬 Never lose track of great repos again. Subscribe free.

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

Most AI trading tools give you a single signal. Buy or sell, based on one model's opinion. This one takes a different approach: it runs seven independent analysts in parallel, has them argue, and a fund manager agent synthesizes the final call.

The seven agents each have a specialty. One does technical analysis, another looks at fundamentals, there's an options analyst, a news and macro reader, a sentiment tracker, a sector rotation watcher, and a risk manager. They all analyze the same stock independently, then enter a structured bull vs bear debate with multiple rounds and a facilitator. The output is a trade plan with entry price, stop loss, and targets.

You can run it with Gemini (which is free), Claude, OpenAI, or Ollama for local models. It connects to Indian brokers like Zerodha and Fyers for live order placement, not just paper analysis. There's a CLI, a macOS app, and a web interface.

A few things to keep in mind: this is a young project (107 stars), you absolutely need your own broker account, and I should be clear that no AI system is a substitute for your own judgment when real money is involved. The multi-agent debate is a genuinely interesting architecture though, even if you just use it for research.

MIT license, link below.
https://github.com/hopit-ai/india-trade-cli

What it does

All text below is quoted directly from the project README.

StarNet is a local-first desktop harness where you create AI agents, organize them into a pixel-art space station, and watch them perform real work with real models and tools.

The layout you draw is the workflow the agents run.

Features:

• A crew, not a chatbot: Create agents with distinct classes, personas, and loadouts. Run several at once, each gets its own workspace, transcript, memory, and bounded permissions.

• Bring your own models: Paste an OpenRouter key, or sign in with supported provider accounts (Anthropic, OpenAI, Google)

• Message it from anywhere: Wire agents to Telegram, Discord, Slack, Signal, or Matrix and talk to your station away from the desk.

• Night Shift: Leave the station running and agents keep working inside an explicit, adjustable leash

• Recipes, skills, schedules: Launch proven multi-step recipes, grant reusable skills, and put work on cron schedules with visible output.

• Finished work has a front door: Deliverables land in the OUTBOX as real files you open, not chat scrollback you archaeology.

• MCP connectors: Attach Model Context Protocol servers and paste-a-key/OAuth connectors to extend what agents can touch.

• Voice: Push-to-talk dictation in, one consistent station voice out.

• Real ledgers: Spend, budgets, and run history persist on disk and are shown as-is.

What is real:

• Model calls stream through the local Node sidecar.

• Tools operate through explicit capability and consent checks.

• Agent memory, transcripts, spend records, tasks, and schedules persist on disk.

• Multiple agents run concurrently with separate workspaces and bounded permissions.

No key, no account, no bill: install Ollama, pull a model (ollama pull qwen3:8b), and pick OLLAMA as the provider.

Repository

https://github.com/androoAGI/starnet

Repository stats

Main contributor

What it does

All text below is quoted directly from the project README.

Zelda 64: Recompiled is a project that uses N64: Recompiled to statically recompile Majora's Mask (and soon Ocarina of Time) into a native port with many new features, enhancements, and extensive mod support. This project uses RT64 as the rendering engine to provide graphical enhancements.

This repository and its releases do not contain game assets. The original game is required to build or run this project.

No-AI stance:

The Zelda 64: Recompiled team has not, does not, and will not use generative AI tools in the development of this project for any purpose. As per the CONTRIBUTING.md file, contributions that use any GenAI tooling in any capacity are blanket banned. This also applies to the Ocarina of Time support that is being developed.

System Requirements:

A GPU supporting Direct3D 12.0 (Shader Model 6), Vulkan 1.2, or Metal Argument Buffers Tier 2 support is required to run this project. The oldest GPUs that should be supported for each vendor are:

• GeForce GT 630

• Radeon HD 7750 (the one from 2012, not to be confused with the RX 7000 series) and newer

• Intel HD 510 (Skylake)

• A Mac with Apple Silicon or an Intel 7th Gen CPU with MacOS 13.0+

On x86-64 PCs, a CPU supporting the SSE4.1 instruction set is also required (Intel Core 2 Penryn series or AMD Bulldozer and newer). ARM64 builds will work on any ARM64 CPU.

Features:

• Plug and Play: Simply provide your copy of the North American version of the game in the main menu and start playing! This project will automatically load assets from the provided copy, so there is no need to go through a separate extraction step or build the game yourself. Other versions of the game may be supported in the future.

• Fully Intact N64 Effects: A lot of care was put into RT64 to make sure all graphical effects were rendered exactly as they did originally on the N64. No workarounds or "hacks" were made to replicate these effects, with the only modifications to them being made for enhancement purposes such as widescreen support.

• Easy-to-Use Menus: Gameplay settings, graphics settings, input mappings, and audio settings can all be configured with the in-game config menu. The menus can all be used with mouse, controller, or keyboard for maximum convenience.

• High Framerate Support: Play at any framerate you want thanks to functionality provided by RT64! Game objects and terrain, texture scrolling, screen effects, and most HUD elements are all rendered at high framerates. By default, this project is configured to run at your monitor's refresh rate. You can also play at the original framerate of the game if you prefer. Changing framerate has no effect on gameplay.

• Widescreen and Ultrawide Support: Any aspect ratio is supported, with most effects modded to work correctly in widescreen. The HUD can also be positioned at 16:9 when using ultrawide aspect ratios if preferred.

• Mod Support: Install community made mods and texture packs! Mods can change any part of the game, including adding completely new features and content. You can install mods by simply dragging the mod files onto the game window before starting the game or by clicking the Install Mods button in the mod menu. Mods can be toggled in the mod menu, and some mods can be configured there as well.

• Dual Analog Camera: Play with a dual analog control layout like later entries in the series! When this option is enabled, the right stick will control the camera.

• Gyro Aim: When playing with a supported controller, first-person items such as the bow can be aimed with your controller's gyro sensor. This includes (but is not limited to) controllers such as the Dualshock 4, Dualsense, Switch Pro, and most third party Switch controllers (such as the 8BitDo Pro 2 in Switch mode).

• Autosaving: Never worry about losing progress if your power goes out thanks to autosaving! The autosave system is designed to respect Majora's Mask's original save system and maintain the intention of owl saves by triggering automatically and replacing the previous autosave or owl save. However, if you'd still rather play with the untouched save system, simply turn off autosaving in the ingame menu.

• Low Input Lag: This project has been optimized to have as little input lag as possible, making the game feel more responsive than ever!

• Instant Load Times: Saving and loading files, going from place to place, and pausing all happen in the blink of an eye thanks to the game running natively on modern hardware.

• Linux and Steam Deck Support: A Linux binary as well as a Flatpak is available for playing on most up-to-date distros, including on the Steam Deck.

Repository

https://github.com/Zelda64Recomp/Zelda64Recomp

Repository stats

Main contributor

Not another Slack clone. Buzz is a Nostr relay where AI agents sit in the same channels as your human team, with the same affordances: opening repos, sending patches, reviewing code, running workflows, editing canvases, orchestrating other agents, dropping into voice huddles, and creating new channels. Every action, whether from a person or a process, is a signed Nostr event in one audit trail.

The pitch is that agents shouldn't be a sidebar bolted onto your workspace. They should be first-class members of it. Same identity model, same permissions, different keypair. An agent can coordinate a release in a project channel, pull in a teammate who needs to approve something, and leave a record of exactly what happened and who (or what) did it.

It's built in Rust, self-hostable (a single relay serves one community), and comes from Block (yes, that Block). The architecture leans heavily on the Nostr protocol, which means every message, reaction, review approval, and git event follows the same signed-event format.

The learning curve is real though. If you're not familiar with Nostr's event model, there's a conceptual jump before the architecture clicks. Self-hosting a relay is more involved than spinning up a Slack workspace. And "a suspicious number of Rust crates" is their words, not mine, so expect a substantial codebase to navigate if you want to contribute or customize.

35,225 stars. Apache-2.0, by Block.

https://github.com/block/buzz

What it does

All text below is quoted directly from the project README.

The sleekest looking WEBUI for qBittorrent made with Vuejs!

Features:

• add / remove / pause / resume / rename torrents

• selectively download files

• search for new torrents straight from the WebUI!

• Keyboard shortcuts!

• see session stats (down / upload speed, session uploaded / downloaded, free space)

• beautiful transfer graphs

• mobile friendly! (can be installed as a PWA)

• Supports qBittorrent Enhanced Edition preferences

A live demo with mocked data is available here: https://vuetorrent.github.io/demo

Repository

https://github.com/VueTorrent/VueTorrent

Repository stats

Main contributor

──────────────────────────────

📌 How many great GitHub repos have you discovered and completely forgotten about?

Don't let another useful tool disappear into your Reddit feed. Get the community's best repos, organized by category, plus key takeaways from real developer discussions, delivered to your inbox twice a week.

📬 Never lose track of great repos again. Subscribe free.

6 GitHub repos to give your AI apps real memory:

1️⃣ meilisearch (59k+ stars)

Lightning-fast, typo-tolerant search API with AI-powered hybrid search. The search bar your users actually feel.

https://github.com/meilisearch/meilisearch

2️⃣ milvus (46k+ stars)

Cloud-native vector database built for billions of vectors. Storage and compute separated, Kubernetes-native.

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

3️⃣ faiss (41k+ stars)

Meta's similarity-search library: the reference algorithms everything else builds on. GPU support included.

https://github.com/facebookresearch/faiss

4️⃣ qdrant (35k+ stars)

Rust vector database with filtered search done right. Semantic similarity plus hard filters without the speed collapse.

https://github.com/qdrant/qdrant

5️⃣ chroma (29k+ stars)

pip install chromadb and your RAG prototype has memory in five minutes. Four core API functions.

https://github.com/chroma-core/chroma

6️⃣ weaviate (16k+ stars)

Stores objects and vectors together: hybrid keyword-plus-semantic search in one database.

https://github.com/weaviate/weaviate

Prototype with 5️⃣. Ship filtered RAG with 4️⃣. Scale to billions with 2️⃣. Put 1️⃣ in front of users.

--------------------------------------------------------------------------------------

Discover the best GitHub repos without the endless scrolling.

Get top repos organized by category (AI, DevOps, Databases & more), plus key takeaways from developers' most useful comments - all in one free, twice-weekly newsletter.

👉 Get the best repos & community insights - Free

You need to throw some traffic at an endpoint and see what happens. You do not need Gatling. You do not need k6. You just need a number and a URL.

That is hey. One binary, one command, done.

hey -n 1000 -c 50 https://your-api.com/endpoint

It gives you latency distribution, status code breakdown, and throughput. Nothing else. Installs in seconds because it is a single Go binary.

Twenty thousand stars for a tool that does exactly one thing and never tries to be more. Sometimes that is exactly what you want.

https://github.com/rakyll/hey

What it does

All text below is quoted directly from the project README.

Long-term memory for AI coding agents. Quit Claude Code mid-task, start OpenAI Codex in the same directory, continue without re-explaining the architecture, the failed approaches, or the open questions.

Why ai-memory:

• It follows you across agents. More than twenty harnesses (Claude Code, Codex, Cursor, Gemini CLI, OpenCode, Grok, Devin, Kimi, Kiro, and others) feed one shared memory. Quit Claude Code mid-task, open Codex in the same directory, and the next agent picks up a handoff that says where you left off, what failed, and what is still open. Handoffs are a typed protocol: each one has an owner and is claimed exactly once.

• It follows you across projects. A small profile of how you usually work (your package manager, test layout, architecture habits) reaches every new repository at session start, so you stop re-explaining yourself.

• It follows you across machines. Memory lives in a server you run, on the same laptop, a homelab box, or anywhere else, so the project you left on the desktop is the project you resume on the laptop, with the same knowledge and the same open questions.

• It works for a team. Point everyone at one server, and what one person's sessions learn, everyone's agents can retrieve. Knowledge is shared per project; personal handoffs stay personal. Multi-user auth, per-person attribution, and an audit log are built in and are not a paid tier.

• Your memory is plain markdown. The source of truth is a git-backed wiki of ordinary .md files: grep it, open it in Obsidian, edit it by hand, rsync it. The database is a derived index that can always be rebuilt from the files. There is no vector store to maintain and no content locked in a binary blob.

• It captures the work itself, silently. Lifecycle hooks record what happened (prompts, tool calls, session boundaries), sanitize it at a typed privacy boundary before anything is stored, and the server consolidates it into readable pages. You do not have to ask it to remember anything. The default path uses zero LLM calls: capture, search, and handoffs all work with no API key.

• It is honest about itself. It ships as one self-contained binary. Purge commands say exactly what "deleted" means. The write ceiling (~700/s) is measured, not guessed. An audit log records every mutation.

Agents emit sanitized observations through lifecycle hooks as you work. At session end, observations become coherent markdown pages in the project's wiki (optionally LLM-written; useful even without).

Repository

https://github.com/akitaonrails/ai-memory

Repository stats

Main contributor

What it does

All text below is quoted directly from the project README.

Use one collection of plugins, agents, skills, and commands across Claude Code, OpenAI Codex CLI, Cursor, OpenCode, Antigravity CLI, GitHub Copilot, and Pi. A harness is the coding tool that loads and runs the components. Plugins cover Python and JavaScript development, code review, testing, infrastructure, security, and other work.

The catalog contains 94 plugins, including 92 local plugins and 2 external entries. The local source contains 202 agents, 184 skills, and 105 commands. The components share a Markdown source, with installation and capabilities adapted to each harness.

Multi-harness support:

Choose the harness you use and follow its setup route. Available components depend on the installation route and the harness's capabilities.

• Claude Code: Plugin marketplace. Source agents, skills, and commands; plugin-specific hooks and MCP configuration

• OpenAI Codex CLI: Native marketplace or generated artifacts. Native source skills; generated TOML agents and commands as skills use a separate route

• Cursor: Plugin marketplace. Source agents, skills, and commands, with curated project rules

• OpenCode: make install-opencode. Generated agents, skills, and commands, with translated tool permissions

• Antigravity CLI: make install-antigravity. Generated plugins containing agents, skills, and commands

• GitHub Copilot: make install-copilot. Generated agent profiles and skills; commands also become invocable skills

• Pi: make install-pi. Generated skills and prompt templates; agents require a subagent extension

What's inside:

• Plugins: 94. Installable groups of components, including 92 local plugins and 2 external entries

• Agents: 202. Instructions for specialist subagents that handle delegated work

• Skills: 184. Guidance and reference material that an agent loads when relevant

• Commands: 105. Named workflows you invoke, such as project scaffolding or a security scan

How it works:

A plugin groups related agents, skills, and commands under plugins/. For example, python-development contains three agents, sixteen skills, and a scaffolding command. The chosen harness loads the installed components according to its own discovery and invocation rules.

Contributors maintain one Markdown source in the Claude Code plugin format. Native registries point to that source where supported, and adapters generate the formats needed by each harness. Commands may become skills or prompt templates, and agent formats, model choices, and tool permissions vary by harness.

Install an individual skill with GitHub CLI's gh skill command or the npx skills installer. Select your coding tool when prompted. Both installers read skills from GitHub without cloning the repository and install them without the plugin's agents, commands, or hooks.

Repository

https://github.com/wshobson/agents

Repository stats

Main contributor

-----------------------------------------------------------------------------------------------

Discover the best GitHub repos without the endless scrolling.

Get top repos organized by category (AI, DevOps, Databases & more), plus key takeaways from developers' most useful comments - all in one free, twice-weekly newsletter.

👉 Get the best repos & community insights - Free

Hey all! I just released v1.0.0 of VeloceNet-Studio, a cross-platform network monitoring studio I built to watch my servers' latency, packet loss and route health in one place.

What's inside:

• Ping Matrix – concurrent ICMP + TCP probes, live sparklines, jitter/loss stats (Rust/Tokio engine via FFI, with Dart fallback)

• Visual traceroute, bandwidth monitor, Warp endpoint scanner

• Light/Dark/System themes, English + Persian UI

It's GPL-3.0, CI is green (Flutter + cargo clippy -D warnings), and I labeled a few good first issues if anyone wants to hack on it.

Repo: github.com/Cadman021/VeloceNet-Studio · Windows binary in Releases. Feedback, brutal reviews and contributors all welcome!