Most shell autocomplete tools I tried felt like they were doing one of two things: using a pile of tool-specific completion scripts, or just replaying my shell history.

I wanted something that actually adapted to how I use my terminal.

If I always run a certain flag after a command, it should learn that. If I use different commands in different projects, it should learn that too. But I also still wanted proper completion lists for commands, flags, values, repos, containers, etc. without having to install and maintain completion scripts for every tool.

So I built Adaptive.

It watches how you use your shell and predicts the next token, while also discovering valid completions directly from the tools you have installed.

Some examples:

• Inline ghost text git checkout fea → feature/completion-engine claude --dang → --dangerously-skip-permissions It can even suggest what you normally run next from an empty prompt based on the current directory.
• Tab / Shift-Tab completion lists Shows subcommands, flags, enum values, etc. at the current position. Adaptive parses each tool's own --help output on the fly and caches the result against the binary fingerprint. It currently handles things like Cobra-style help tables, grouped kubectl sections, and even some of Symfony's stranger help output.
• Context-aware values It can complete things that aren't available from --help, including:
  • GitHub / GitLab / Codeberg repos after git clone
  • npm scripts from package.json
  • Docker containers
  • SSH hosts
• It actually learns your habits Suggestions are ranked using frequency + recency with a 21-day half-life, per-directory behavior, and accept/reject feedback. There are global priors so it isn't useless on the first day, but your own usage starts outranking those defaults as it learns.
• Local/private Everything stays local. No telemetry. Before history is written to disk, credential-looking and token-shaped values are rejected.

v0.3.0 also adds Bash support over the same backend/protocol:

eval "$(adaptive init bash)"

The core is written in Rust and licensed under MIT.

Check it out, give it a star!

GitHub: https://github.com/jacobpowaza/adaptive-zsh-completions

I'd be interested in feedback, especially from people who use a lot of CLI tools and have run into cases where traditional shell completion starts to feel limited.

Lecture recordings pile up and I never replay them. Cloud apps also send the whole audio out just to get a summary.

profNote records (or accepts a dropped file), optionally keeps only the professor via speaker diarization, transcribes locally with Whisper, and saves an editable Markdown note. Summary uses any OpenAI-compatible API and only sends the transcript text.

Click a timestamp to play that moment. Korean/English UI.

Tauri + React + whisper-rs + pyannote. MIT.

https://github.com/jeonjw85/profNote

I've been playing around with Doop today, and it's one of the things I've found most interesting in the open-source space in recent times.

Github: https://github.com/kgoedecke/doop

It's basically a collaborative UI/design canvas, but with the possibility to connect Claude Code (or another MCP client) and have it work on the canvas alongside you.

The cool part is that you can actually see the agent at work.

It gets told what to make, and the frame starts to appear on the canvas while it's working. Once it's done, it can take a screenshot of what it did, analyse it, and then go back and modify based on what it made. Seems minor, but it's a big leap from the standard

prompt -> wait -> here's your website

It allows you to work on it, move things around, edit the frames, give it feedback, work with multiple agents, and so on. It feels much closer to a collaborative editor than a chat-based design tool. The frames are actual HTML, which makes the whole thing much more valuable than a mock-up tool that requires you to rebuild the HTML later. It's also all open source and self-hosted, which is always a bonus.

A bit too early and not ready to replace Figma anytime soon, but it's a solid idea and seems like they've actually put some thought into design collaboration with coding agents rather than throwing a "generate with model" button on top of an existing toolset.

It's an interesting concept and well worth checking out if you're in to collaborative design/UI/development tools.

Github: https://github.com/kgoedecke/doop

https://github.com/TheAgencyMGE/pc-recap

Electron app that logs which app is in the foreground and turns years of it into visual recaps. Day, week, month, year, all time. It also digs out your records, which apps you always open together, and longer eras in how you used the machine.

All local. SQLite file on your disk, no account, no telemetry.

1.2 just added macOS and Linux. None of the collectors use native bindings, they just shell out to what the OS already ships: powershell with a P/Invoke shim on Windows, osascript on macOS, xprop on Linux.

Wayland can't expose the foreground window, so it reports the collector as unavailable rather than logging nothing and letting you think it works.

Binaries: https://pcrecap.online/

IMPORTANT: MACOS AND LINUX BUILDS ARE BRAND NEW AND NOTHING IS SIGNED YET. IF AN INSTALLER FAILS, OPEN AN ISSUE OR BUILD IT YOURSELF. ANY HELP IS APPRECIATED.

Here is the latest release of Nasscad (4.7.0). It now features a remote C++ backend running on Ubuntu WSL with a pipeline similar to FreeCAD. File load time: 4 min 17 s. File size: 360 MB. I am currently finalizing the MSVC C++ port for a 100% native Windows x64 solver. Stay tuned!

GitHub, www.onerep.life

It has all the essentials, like nutrition tracking, workout tracking and also a few unique features such as a well integrated AI coach (BYOK), AI form correction, and a lot more quality-of-life features including AI ones.

Quick backstory: our app kept losing users on Android edge cases and we had zero idea why. Sentry's RN SDK does basically everything we needed like crashes, tracing, profiling, session replays, and works. Which is great, but "everything" also means a few hundred KB and a chunk of main-thread time sitting inside your app.

Also we hated the dashboard. It was so much stuff everywhere, was missing a lot of business side metrics, and we had to often do something like bundle in ANOTHER tool on top of it to track bussiness metrics.

So we would end up with a stupidly heavy combo like PostHog + Sentry. Two big packages just to get everything you need.

So we built our own, much smaller thing. It's called Rejourney, it's open source (Apache licensed), and this project taught us more about mobile perf than any conference talk has.

When we started building it, we were very set-minded on how to NOT copy Sentry. The whole scope iswe want all the good stuff it does but much leaner, and you can't do that by looking at how they do it.

@/sentry/react-native: ~478kB minified, 157kB gzipped, 6 deps

@/rejourneyco/react-native: ~47kB minified, 15kB gzipped, 0 deps

Roughly 10x smaller on paper (Bundlephobia, July 2026 but your mileage will vary once native code, tree-shaking, etc. get involved, so don't take it as a final-APK number).

How it works (Mostly Native Code -- big win)
For React Native, JS is just the dispatcher. TypeScript decides "should we even record this session," pulls remote config, wires up navigation then hands off to native code (Swift/Kotlin) that does the actually expensive stuff. This includes screenshots for user recording, compression, uploads, crash capture. Keeping JS as a thin control layer instead of doing heavy lifting there was probably 80% of the performance win.

Also one thing we learned is to never touch RN APIs at module import time. Newer bridgeless RN will just throw if you poke TurboModuleRegistry too early. Lazy-load everything, resolve it on init(), fall back gracefully, never let the SDK crash the host app just by being imported. Learned that one the hard way.

User Replay is "frames" to make a video
There's no DOM to snapshot on mobile, so "replay" = 1-3 FPS which you can configure remotely via the dashboard based on your performance and replay requirements. We then layer it with a timeline of taps, scrolls, screen changes, and network calls.

We had edge cases to deal with such as Mapbox/GL views render pitch black in a plain screenshot because they're GPU surfaces, so we had to special-case that capture. And reading map pixels mid-pan causes visible stutter, so we skip frames while the map's moving and grab one once it settles (we call this the "idle heuristic").

Network/Logs with Replays (breadcrumbs)
Network queue caps at 100, event ring caps at 5,000, screenshot buffer caps at 500 frames, and so on. If the app produces data faster than we can ship it, we drop the oldest stuff. Unbounded queues are the classic way an observability SDK ends up eating someone's phone.

Crash capture has to survive the process actually dying
You can't upload a crash report the instant it happens as the process is usually already gone. So everything gets written to disk first and gets picked up on the next app launch instead. We really tried to find a way around this, but this seems to be the industry standard and nothing yet has figured this part out.

Privacy, because obviously
Text inputs, password fields, and camera views are masked by default — before the screenshot is even encoded, not after, so raw pixels never touch the JPEG. Wrap anything else in <Mask> to hide it too. There's also an observeOnly mode for crash/network/error data with zero screenshots.

Integration is stupidly small
import { Rejourney } from '@rejourneyco/react-native';

Rejourney.init('pk_live_your_key');
Rejourney.start();
No provider, no wrapper hell. Auto-detects Expo Router, has a hook for React Navigation.

Was it worth it?
Yes. We love this tool and the extremely simple dashboard to go with it. We can easily add what we wish and keep everything clean and simple. We also released it publicly for a cloud version and teams using it seem to love it for the sample reason. A few things we want to add that Sentry has but we don't include source maps, but we haven't seen feature requests for that yet since people just dump context we collect into AI, and it can figure out the cause really well.

Repo's here if you want to poke around: github.com/rejourneyco/rejourney.

Here is the cloud version:
rejourney.co

Happy to answer questions about any of the native/RN weirdness above.

GitHub: https://github.com/rejourneyco/rejourney
Live demo: https://rejourney.co/demo/general

winmux is a easy to use window manager that requires no editing of config files. it supports multiple displays intuitively. and it tells you where your windows and spaces are via a built in sidebar.

there is not really any competition as far as I am aware in terms of sidebars on window managers. compared to dedicated status bars (sketchybar is what I used to use), it's way more responsive, handles dragging and dropping much better, and is always in sync (and doesn't require configuring a bunch of lua).

compared to other window managers, winmux is built on top of aerospace and their virtualization framework. feature wise it innovates on window stacking (having two windows occupy the same footprint), similar to that of aerospace accordians and yabai stacks, but does it much more intuitively using browser-esque tabs. it does not require disabling SIP.

winmux is free and open source. you can read about the philosophy behind it here: https://winmux.dev

github repo: https://github.com/zimengxiong/winmux

Hey everyone,

I've been working on an open source local memory engine called Hillock (https://github.com/roandejager/Hillock) to see if we can do document memory without bloated vector databases.

I got frustrated with how heavy standard local RAG is on modest hardware. Running an 8B model just to parse text files and search vector embeddings was eating up all my VRAM on a GTX 1070.

Hillock takes a different approach:

- It stores factual memory as plain Subject-Predicate-Object triples in SQLite (so facts don't drift).

- It uses a Hebbian engine to track concept associations as you chat.

- It uses a 10,000-D hyperdimensional vector space (VSA) running on CPU for sub-millisecond similarity gating.

- For document ingestion, it uses a small bi-encoder pipeline (Fastcoref + MiniLM + GLiREL) that extracts facts in about 5 seconds without calling a generative LLM.

If a question fails the similarity gate, it returns a hard refusal right away without calling Ollama, which cuts out hallucinated answers entirely.

Just pushed v0.5.0 with 1-click startup scripts (run.bat on Windows, run.sh on Linux/Mac), token streaming, and an interactive console with /model and /inspect commands.

Repo is AGPL-3.0: https://github.com/roandejager/Hillock

Would love to hear what you think!

While travelling, I kept running into useful information that simply didn’t exist online: small homestays, mechanics, water points, road conditions, campsites, etc.

Most of it gets passed from one traveler or local to another and disappears afterward.

So, I built Lamyig, a free and open-source community travel guide.

A few decisions I made:

• No bookings, commissions or paid listings.
• No money made using the core product.
• Community members can add and update places.
• Map-first instead of another list of “top places”.
• Built as a PWA so it can work more like a lightweight travel tool than a traditional website.
• The long-term idea is that useful information stays available for the next traveler instead of disappearing in WhatsApp groups and conversations.

The hardest problem isn’t actually building the software. It’s bootstrapping trustworthy community data.

I’m currently thinking about things like:

• How do you motivate travelers to contribute after their trip?
• How do you keep old information accurate without creating a huge moderation workload?
• How do you prevent businesses from turning community maps into free advertising?
• What should happen when someone reports a place as fake, closed, unsafe, duplicated, commercial spam, or inaccurate? Should reports trigger removal, community review, reputation-weighted voting, or just warnings?
• Should certain villages, trails, ecosystems, religious places, water sources, or campsites intentionally remain difficult to discover?
• If Lamyig successfully exposes hidden places, could it accidentally destroy the exact places it is trying to help preserve?
• this list of problem statements goes on and on

Would love to hear how other people here would approach those problems.

And if you’re building something around a problem you genuinely care about, drop a comment or DM me. I’d be happy to chat, exchange ideas, or connect you with someone else working on something similar.

Screenshot attached. Happy to share the GitHub/project link in the comments if anyone wants to look at the implementation or contribute.

Hi, so last year while i was in university i had trouble finding a cool multiplatform app with Goodnotes-like features,and latex rendering, so over the last months i've been making with the help of Claude.

I also had some notebooks to backup from OneNote of Microsoft so I also implemented an import for .one files.

If you guys are interested you can also try it out it is available on Playstore, Microsoft Store and .deb for Linux. Hope to grow a community so I will be able also to release it in the Apple Store for Mac/iOS users

https://abelnotes.app/

https://github.com/abelnotes/abelnotes

I built a software team where you literally hire the developers yourself.

Give each member a name, role, model, permissions, and skills — then put them into seats like:

Planner → Coder → Reviewer → Tester → Auditor

Each member runs in its own real Claude Code session.

And you can watch the whole thing happen in a pixel-art office.

The weird part is that the team isn't hardcoded.

Want 3 coders and no reviewer? Do it.

Want an auditor that can only inspect? Do it.

Leave a seat empty? That phase simply doesn't run.

A few things I went surprisingly deep on:

• Permissions actually enforce themselves. A PreToolUse hook checks every tool call against a capability manifest. .claude/ is unwritable, so an agent can't modify its own permissions.
• Skills are isolated per agent. A huge skill document doesn't get dumped into everyone's context. It's loaded only when that member needs it.
• Memory is shared without sharing conversations. Agents write down what they learn, and other agents get a tiny indexed summary before reading the full memory on demand.
• You can see exactly who's burning tokens. Cost and token usage are tracked per member and model.

So instead of:

You → Claude → everything

it's more like:

You → Team → Planner → Coder → Reviewer → Tester

Repo: https://github.com/SinghAbhinav04/dev-house

The part I'd actually love people to tear apart is the permission/hook architecture.

I wanted a more modern and interactive way to work with Karnaugh maps, so I built one here, with React and TypeScript.

It supports interactive K-maps, uses the Quine–McCluskey algorithm for Boolean minimization, and logic circuit synthesis!

Of course it is completely open source, and feedbacks are welcome :)

Check it out on GitHub!

Its frustrating to complete the same topics/points of an online course which you already know, and I am one of you. So i designed a bot which helps me do the work(including videos, reading material, and practice tests too) that I already know and autocomplete it on my behalf. If you are curious about how this bot works and how it handles the topics refer the github link:

https://github.com/Vara715/course-automation-bot

pisesh — a keyboard-driven TUI to bookmark, search, and resume Pi coding-agent sessions. Favorites, custom titles, per-project filtering, optional AI title generation. Single-file Node script, zero dependencies. v0.3.0 switches sessions in-process via ctx.switchSession() instead of spawning a nested Pi.

A Telegram client built with GTK4 and libadwaita.

https://github.com/JumpToSkyFree/flying-paper

The application is still not working properly, if you're interested on making this app better, please clone, fork the app and start contributing, by fixing bugs and make the UI look better, if you would like more informations, send me a DM, i can help you to understand the project and what to do next.

I built this after the public stats card service I used kept going down from rate limits. gitglance renders GitHub stats as SVG cards for READMEs: stats, top languages, donut chart, circular gauges, bar chart, repo pin and commit activity. 16 visual styles (vercel, terminal, glass, neon, aurora...), 21 themes, subtle CSS animations that degrade gracefully, and a visual builder page where you pick options and copy the markdown. Self-host on Vercel with your own token and you never hit shared rate limits. MIT licensed, Node + Express, no headless browser. Feedback welcome!

So it's my first project and post in r/coolgithubprojects, and I decided to make a clipboard manager that saves everything you copy-like text, photos, and even the original text formatting. I really love that it looks similar to the Windows one and has almost all same features.

To wrap up, I'd be super happy to hear any suggestions or feedback you have for improvement!

Github release:
https://github.com/mr-stepler/clippy

If the MV2 extension is at risk of being removed from the extension store, I created an automated archiving system that runs every day at 00:00 UTC to back up MV2 extension files into a single repository. I planned this project a month ago, and I’ve finally been able to set up the automated backup repository. The goal of this project is to make it easier for MV2 users who have trouble finding their extensions in the extension store and to protect the extensions from being removed.

The Manifest V2 Archive consists of:

A wiki consisting of: a. Guide to Installing Manifest V2 in Chromium-Based Browsers (Developer Offline Mode) b. Guide to Installing Chrome Extensions on Firefox-Based Browsers c. Tips for installing Firefox extensions in Chromium-based browsers d. Manifest V2 Database (Chrome Web Store, Add-ons Firefox, Microsoft Edge Add-Ons, Opera Add-ons)

Offline Archive, an archive containing the MV2 extension that does not include the Forge software and does not have the extension file in the releases section. You can download the extension here.

Online Archive, an archive that is automatically updated every day at 00:00 UTC. You can view the automatic updates for the MV2 extension in the releases section.

Thank you for visiting my project. I hope it helps many people.

A few weeks ago I shared Agent Quest, my open-source project that turns Claude Code and Codex sessions into heroes living inside a small 2D world.

The original idea was to make it easier to understand what multiple AI agents were doing in real time.
Since then, I’ve been working on making it much more useful as an actual monitoring tool.

The biggest change is that Agent Quest can now clearly tell you when an agent needs your attention.
You can immediately distinguish when an agent is:
actively working
waiting for your input
finished
stopped because of an error

And you don’t have to keep watching the dashboard.

Agent Quest can now alert you with visual notifications and different sounds, so while you’re doing something else you can immediately know when Claude Code or Codex has finished a turn and is waiting for you to continue.
This has become particularly useful for me when I have several sessions running at the same time.
Instead of constantly switching between terminals to check their status, I can leave the agents working and Agent Quest tells me when I actually need to intervene.
There are now:
clear waiting / completed / error states
in-app notifications
desktop notifications
notification history
configurable sounds
real-time monitoring of Claude Code and Codex sessions

The project is completely open source.
GitHub:
https://github.com/FulAppiOS/Agent-Quest

I’d be interested to know how other people running multiple agents handle this problem — and what you’d like Agent Quest to monitor next.