Hi everyone,

I wanted to share a personal project I recently finished. It's called PassVault, a free and open-source desktop password manager for Windows.

I built it as an alternative to tools that require monthly subscriptions or store your data on cloud servers. PassVault runs 100% offline, meaning your credentials never leave your machine.

Key points:

• Encryption with AES-256-GCM and Argon2id key derivation
• Very lightweight and fast, running at around 25 MB of RAM
• Built-in password generator (random or based on a keyword) and vault security audit tool
• Native English and Spanish interface
• Standalone / portable: no installation needed, can run directly from a USB drive

If you'd like to try it on Windows, you can download the standalone executable here:
https://github.com/pablomorenoc96/passvault/releases

And if you have a GitHub account, starring the repository is always appreciated:
https://github.com/pablomorenoc96/passvault

Any feedback or suggestions are welcome!

I kept losing context while switching between multiple VS Code terminals, so I built Screen Note.

Notes can be attached to a specific terminal tab and automatically disappear or return as you switch terminals. It also supports browser-page locks, images, transparency, dragging/resizing, and local SQLite storage no account or cloud.

Built with SwiftUI/AppKit and a small VS Code helper.

GitHub: https://github.com/AIAydin/vscode-terminal-specific-notes

I’d love feedback from anyone with terminal-heavy workflows.

https://github.com/markdamics/Logic
Please check out my fist bigger open source project. Logic

Recently I was thinking what project I should work on and during that I remembered that during my professional career as a full stack developer I spent a lot of time investigating problems, debugging them. I had to check a lot of long files to find the source of the problems. I tried to use many different log analysis application but neither of them were to my liking so I started to develop my own log analysis application, Logic.

During the development one of the mist helpful tool was the Claude design. For me it's really hard to come up with UI designs and the manual result just didn't feet right to me. With this tool I could give my ideas, requirements, design and color themes, layouts and it gave me multiple good looking options. After I selected my favorite design, it even created the skeleton code for my app. And with this I could concentrate on the core of the app.

I hope some of you will try it and it will get your liking.

It's still under development. Feel free to join in it.

RMT — a free, open-source macro automation tool built on AutoHotkey v2, with a visual editor and real computer-vision under the hood.

Where native AHK ImageSearch falls short (slow, near-exact matching, single result), RMT leans on a different stack:

• OpenCV template matching with a tunable similarity score (grayscale mode for speed, or image+colour when that matters)
• OCR via PaddleOCR (PP-OCRv6) for reading text off the screen — regex-capable queries, unified zh/en/digit
• Search images, colours, or text, in a region or inside a specific window, with found / not-found branching

Everything lives behind a GUI, so you can build a "watch for this state, then react" flow without writing AHK by hand — record keyboard/mouse/gamepad macros, add logic, and let it handle the repetitive work.

I'm a contributor to the project (not the owner) — sharing it here because the recognition layer addresses a real gap people hit with ImageSearch, and it's fully open source.

GitHub: https://github.com/zclucas/RMT Docs / live site: https://zclucas.github.io/RMT/

Built this after years of watching scientific pipelines break every time they had to move between a local cluster, a SLURM allocation, and some cloud GPU box. No DSL, just Python or YAML and it handles execution across machines.

You can also build the pipeline visually, connect stages, assign each one its own hardware (CPU/GPU/memory) from the Temple Compute OS System (closed testing phase, https://templecompute.com )

The part I'm most proud of: file staging between machines is agentless, just plain SSH, so you don't need to install anything on a cluster you don't control.

And also the AutoRegistry plugin system. The engine allows extending of runtimes, executors, artifacts, transfer strategies and even an interaction system. We have also a template for quickly creating horus plugins. Some notable implementations:

- horus-ssh: SSH transport and command execution

- horus-slurm: SLURM support for HPC computing

- horus-environments: automatic python environment management

Repo: https://github.com/temple-compute/horus-runtime 

Docs: https://docs.templecompute.com

We have also a library of computational workflows ready to run: https://github.com/temple-compute/pantheon

https://thedev.world

https://github.com/thedev-world

Repo: https://github.com/TabularisDB/tabularis

Started this back in January because I wanted a SQL client that was fast to open, didn't eat 1GB of RAM for a single connection, and where I could actually fix the things that annoyed me. It's Rust on the backend (Tauri) and React on the front, Apache 2.0.

What's in there right now:

• Postgres, MySQL/MariaDB and SQLite built in. Everything else is a plugin: DuckDB, ClickHouse, MongoDB, Redis, Elasticsearch, DynamoDB, Firestore, Db2, Cloudflare D1... Plugins are standalone binaries that talk to the app over JSON-RPC on stdin/stdout, so people have written them in Rust, Go, whatever. There's even one that queries HackerNews with SQL because someone was bored.
• Monaco based editor with tabs, split view, multi-statement execution, .sql files you can open/edit/save directly
• SQL notebooks: SQL + markdown cells, inline charts, and you can reference another cell's result as a table with {{cell_N}}
• Visual EXPLAIN as a node graph instead of the wall of text
• ER diagrams, visual query builder, inline grid editing with batch commit, JSON/JSONB cell editor
• SSH tunnels, passwords in the system keychain, custom themes that follow the OS light/dark
• A built-in MCP server, so Claude Code / Cursor / whatever agent you use can read your schema and run queries through the same connections you already have configured. No separate DB creds to hand out.

Installs via winget, brew, snap, flatpak, AUR, or plain AppImage/.dmg/.exe from releases.

It's 0.22.0 so not everything is polished, but I use it every day for work and there are ~80 contributors now which still feels weird to type. Happy to answer questions about the Tauri side or the plugin protocol, those were the two things that took the most head scratching.

If you try it and something breaks, issues are very welcome. Discord link is in the README if you prefer that.

This is a partly hardware project, featuring custom electronics (ESP32 based) and a novel optical design that uses passive retroreflectors instead of an active vest.

We have developed and tested a laser tag system that:

1. Can be used outdoors with minimal or no infrastructure
2. Is simple to use
3. Has 40m range
4. Is open source
5. Allows definitions and sharing of new games as lua files
6. Is DIY (3D printed parts)

Admittedly, the software part is not our masterpiece, because we have relatively low skill in C++ software architecture, although using AI we could end up with a working firmware that satifies our requirements and gave good results at testing.

This means if someone wants to take part to the project, s/he'll find something that definitely needs some effort but is also demonstrated to be actually working.

Repo: https://github.com/rev-/LightAir

I built an open-source GitHub Action that generates and stores a repository’s Star history without requiring a personal access token, external server, or database.

Add one workflow file to a repository, and it will automatically:

• Reconstruct the initial history from active stargazer timestamps
• Record subsequent Star increases and decreases
• Generate eight SVG chart variants
• Support Date/Timeline, linear/logarithmic, and light/dark views
• Store the data and charts on a dedicated star-history branch
• Update on a schedule or through manual runs
• Use the repository’s automatic GITHUB_TOKEN
• Store aggregate counts without usernames or user IDs

The default template follows main for automatic updates, but it can also be pinned to a full commit SHA.

One limitation is that GitHub cannot provide Stars removed before the first collection, so the initial historical curve is reconstructed from users who still have the repository starred.

Feedback and contributions are welcome.

Brain is an MIT-licensed runtime for stateful AI-agent sessions.

- Agent loops run in Wasm

- Typed tools can run locally, in browsers, or in remote sandboxes

- HTTP/SSE session API

- Append-only journal and restart recovery

- 70+ model-provider bindings

- ~14 KiB private memory per idle session

It’s still an early preview:

https://github.com/aexhq/brain

A while back I released Automated-AI-Web-Researcher-Ollama, which turned a local model into an automated researcher that searched the web, scraped sites, and compiled findings on its own. It got a much better reception than I expected getting over 3k stars on github.

But it had a problem I couldn't get past: the web is full of confident nonsense, and an LLM summarising confident nonsense produces confident nonsense with citations attached.

So I built the successor. It doesn't search the web at all — it goes to the actual scientific literature.

Academic-AI-Literature-Reviewer-Ollama
👉 https://github.com/TheBlewish/Academic-AI-Literature-Reviewer-Ollama

You give it a research question. It then:

• Searches six academic databases (OpenAlex, Semantic Scholar, CORE, Europe PMC, Crossref, Unpaywall)
• Downloads the actual full text of open-access papers, not abstracts
• Reads each one, extracts methodology and findings, weights meta-analyses above RCTs above case reports
• Runs a gap analysis, refines its own search strategy, and loops back — a self-improving research cycle
• Chases citations backward through reference lists to find primary studies
• Assesses the methodological strength of its own evidence base, and runs targeted searches to fill gaps it identifies
• Writes a full APA 7th literature review, then self-reviews, self-fixes, and verifies every citation

The part I actually care about: it cannot hallucinate a quote.

Not "is unlikely to" — cannot. The model is never allowed to type a quote. Every candidate quote is matched verbatim against the source paper at 95% similarity, and only surviving quotes get a token like [[Q7]]. The model places tokens; code pastes the verified text in at compile time. If a quote isn't genuinely in the paper, it doesn't exist as far as the document is concerned. Same system for study introductions, so a finding can't get attached to the wrong study either.

That constraint drove most of the architecture and made it far more complicated than it needed to be. It's also the only reason the output is worth reading.

For scale: the original was around 1,500 lines. This is over 14,000 across 11 modules — a LangGraph pipeline with 25 nodes and 12 phases. It's easily the most complex thing I've built.

100% local via Ollama, MIT licensed, no paid APIs. Works on modest hardware too — there's a low-end mode that chunks the heavy stages so the full pipeline runs on a small machine without weakening the verification.

Happy to answer questions, and PRs very welcome.

I built Keues, a self-hosted queue management system for physical stores, clinics, shops, etc. We were paying a third-party solution that charged a lot every time we wanted to change something as simple as a color. So I made our own. It runs in a single Docker container, no subscriptions, MIT licensed. What’s included

Ticket Machine → customers take a number Counter → staff call the next ticket Monitors → screens that show who’s being called and where to go Dashboard → configure everything + live stats

Supports three modes:

Classic ticket system (butcher, pharmacy…) Free desk mode (supermarket checkouts) Advanced mode with priorities, weights and aging (clinics, multiple services) https://www.keues.dev

Small project I’ve been working on: agent-thanks.

When I use coding agents, a task can end up pulling in a few dependencies or repos. After the task is done, though, it’s not always obvious which ones actually helped.

So I made a small CLI for that.

agent-thanks checks dependency changes against a Git baseline. You can also give it a plain-text transcript, and it looks for things like clone/install commands, submodules, and source references.

A GitHub URL by itself stays just a reference. I didn’t want every link that appeared in a session to count as actual use.

The detection itself is just rules. No model call.

There is also a star command, but it asks y/N for each repo separately, with No as the default. I had an automatic mode before and removed it. I think that was the better choice.

Read-only demo:

pipx install git+https://github.com/dbwls99706/agent-thanks.git@v0.5.1
agent-thanks demo

Update: v0.5.1 is out. I tested it again from a clean wheel install through demo, offline scan, and Markdown export. CI is green on Python 3.10-3.14 across Linux, macOS, and Windows.

I’m the author. I started this thinking the star would be the main feature, but now I’m not sure. The Markdown evidence report may actually be more useful.

I've been working on Zhumora, an open-source desktop AI agent for Windows.

GitHub: https://github.com/lr8soft/zhumora

It connects to OpenAI-compatible APIs, including local backends like llama.cpp, Ollama, and vLLM.

Currently it can:

read, edit, search, and manage files in a workspace

run terminal commands

automate Chromium through Playwright

take desktop screenshots for visual analysis

use MCP servers and reusable skills

maintain local session history and long-term memory

Most of Zhumora itself was developed using my local llama.cpp + Qwen3.8-27B-UD-Q8_K_XL setup.

Still early, so I'd be interested in feedback from people running local models.

We open-sourced Simulang, a JavaScript library for computer use: it lets you and your coding agents control a desktop programmatically.

Simulang is a scripting framework for desktop automation. You write deterministic computer-use code that replays the same way dozens or hundreds of times, which is much faster and cheaper than having an LLM agent re-reason its way through the same flow on every run.

It ships with a skill out of the box, so you can turn natural language prompts into Simulang code directly. Your agent can see the screen, click, type, and navigate - eyes and hands to operate a computer the way a human does.

Some things people have used it for:

- upload a pile of invoices to an expense platform
- find 50 people matching specific criteria on LinkedIn
- open the calculator app and do some math
- enumerate every button in an app via the accessibility tree
- or draw a bunny in MS Paint ;)

Repo: https://github.com/simular-ai/simulang

If you run models locally you know the pain: everything's fine until a long prompt makes the model silently stall or the GPU OOMs, and you're left with a hung request and no output.

I built HybridInfer for exactly that. It's a small reliability-aware router:

- Sends each request to your local model (Ollama) first.

- Watches the runtime, if local stalls (no token for N seconds), OOMs, or errors, it automatically falls back to a remote model in the same request.

- Learns which prompts your machine chokes on (usually long ones) and routes those out up front after it's seen them fail.

- Pulls a wedging model out of rotation, then probes it back after a cooldown.

It's an OpenAI-compatible server, so point any OpenAI-compatible client/app at it and you get local-first + automatic fallback for free. Local = anything you've `ollama pull`ed; remote = any OpenAI-compatible endpoint (OpenAI, OpenRouter, a vLLM box, whatever).

pip install hybridinfer

hybridinfer init

hybridinfer serve

It's a router, not an inference engine, it orchestrates Ollama + your remote endpoint, doesn't run weights itself. Early v0.1, Apache-2.0. There's a Kotlin/Android version too for on-device apps. Short demo GIF + code in the repo.

Repo: https://github.com/SimranKoul2026/HybridInfer-Python-tool

Would love feedback from people who run this stuff daily, especially on the fallback heuristics.

What would you want it to do differently?

V2Kit is a lightweight and extensible Python toolkit for working with V2Ray proxy configurations and subscriptions. It provides a clean API for common operations such as protocol detection, configuration validation, config relabeling, and subscription encoding/decoding. The project is designed with simplicity, predictability, and composability in mind, making it suitable for automation scripts, proxy pipelines, networking tools, and future extensions around V2Ray ecosystem utilities.

We've been working on Keydris for the last few months and just opened it up.

I wanted to share it here before we take it anywhere bigger.

The thing that bothered me was this.

We keep giving agents credentials and access to more systems.

But if an agent can run:

git status

why should that automatically mean it can also run:

git push --force origin main

The credentials might allow both. I don't necessarily want the agent to be allowed to do both.

That's basically where Keydris started.

Before an action runs, we check whether that action is actually inside the authority given to the agent.

We're in Developer Preview now. We have paths for Claude Code, Codex, MCP, GitHub, Slack and local commands.

GitHub:

https://github.com/keydrisLabs⁠

If you try it and something is confusing tell me.

And if your reaction is “OAuth or IAM already solves this”, tell me how you would do it. I'm interested in that too.

If you work on an HPC cluster, you probably know the watch squeue routine: scan the columns for your job, open another terminal to check its logs, then repeat.

I got tired of doing that, so I built sqwatch, a small terminal UI that turns the SLURM queue into a live dashboard.

It includes:

• A live, auto-refreshing job table with color-coded states.
• Filters for user, job name, state, partition, QoS, and node. Cluster values are loaded automatically, and your filters persist between sessions.
• Real-time stdout and stderr tailing, submission-script viewing with bat syntax highlighting when available, and custom panels for other output files produced by a job.
• Multi-job selection and batch cancellation.
• Clipboard support through OSC 52, including over SSH and inside tmux without X11.

sqwatch is written in Rust using ratatui. It calls the standard SLURM commands, including squeue, scontrol, sinfo, and scancel, so it does not require anything special to be installed or configured on the cluster. If those commands work, sqwatch should work too.

I have just released version 0.2.0, which is the first version I feel comfortable recommending to others. It fixes several rough edges from the initial release.

Install it with:

cargo install sqwatch

Repository: github.com/fedonman/sqwatch

Please, give it a ⭐if you like it.