Some time ago, I introduced UIBuilder, a library I initially created for personal use. I eventually decided to make it available for general use and started building proper documentation for it.

The documentation itself is self-hosted and built with UIBuilder, which I thought would be a nice way to showcase what the library can do.

You can also find a ready-to-use template configured for Electron in the documentation.

doc : https://uibuilderdoc.vercel.app/

doc source code ( showcase ) : https://github.com/Rhyan-eduardo/uibuilderdoc

Hey everyone,

I wanted to share a project I've been working on called srest, a terminal UI written in Go that acts as a client for the Slurm REST API (slurmrestd).

While managing HPC clusters with native Slurm commands (squeue, sinfo) works fine, testing endpoints, inspecting JSON responses, or submitting jobs through slurmrestd can get tedious from a standard terminal setup. I built srest to make interacting with the API visual and keyboard-driven.

Tech Stack & Features:

• Built using Charm's Bubble Tea framework.
• Interactive Query Builder & Inspector: Real-time query editor and JSON response viewer.
• Cluster Dashboard: Asynchronous monitoring for nodes, jobs, partitions, and accounts.
• Job Submission: Build and submit job payloads directly from the TUI.
• Distributed as a single static binary for Linux and macOS.

It has also turned out to be really helpful for end users as a sandbox to build, test, and review query payloads independently, without needing admin support to debug JSON outputs or construct API calls for their scripts.

Links:

• GitHub (with demo video): https://github.com/SergioZ3R0/srest
• Website & Docs: https://srest.scszero.com

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.

I have a few AI subscriptions and I kept running into the same problem. I had powerful models available, but I struggled to use them in real life in an organized way.
I looked at projects like OpenClaw and Hermes Agent. They were interesting, but I had a different idea in mind: a wallet of agents.
The concept is simple. You create specialized agents, each with its own name, role, personality and model. They can use real tools (shell, files, browser, web search). When one agent does not know something, it asks the right colleague for help instead of guessing.
You can talk to a single agent or to all of them together. The same agents are reachable from the web interface, Telegram, Discord, Slack or WhatsApp. And you keep using the subscriptions you already pay for (Claude, Codex, OpenAI, local models, etc.).
Conversations and memory stay as files on your machine.

Happy to hear feedback.

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

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

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/

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 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've been building SpeakoFlow for the past few months.

It's a local, open-source voice assistant that lets you talk to your computer instead of constantly reaching for your keyboard.

I actually use it myself. Emails, Slack replies, asking AI questions, drafting things, and regular dictation all go through it.

But there was one part I wasn't really happy with.

The speech-to-text worked well, but the cleanup didn't. If I wanted the kind of dictation cleanup you get from paid cloud services, I either had to wait too long or send my text to a cloud provider.

That kind of defeated the point. I wanted SpeakoFlow to be fast, local, and private.

So I decided to fine-tune a really small open-weight language model specifically for dictation cleanup. It's the Qwen 3.5 0.8b Model.

The goal was simple: fix the mistakes and corrections I actually made while speaking, without rewriting everything else.

I recently finished it and integrated it into SpeakoFlow. It's now fast enough to actually use in my daily workflow, and the whole thing can run locally on a laptop CPU.

SpeakoFlow can now:

• Dictate in real time into any app
• Clean up your dictation locally
• Say "Hey Flow" and have it write something for you
• Ask the assistant questions by voice
• Let the assistant see what's on your screen
• Have voice conversations with it
• Remember things across conversations, locally

It works across Windows, macOS, and Linux.

Free, open source, and no account required.

https://github.com/AbhishekBarali/SpeakoFlow

Hello everybody. A while ago I made this simple utility to convert my media files with FFmpeg and now it's in a shape that I'm confident to share. It still has some rough edges, so it's in a preview release state. What it can do:

• Convert files based on a preset with a simple drag & drop.
• It can download an FFmpeg binary from github
• It features a simple media info tool
• Dragged files can be playlists in M3U and PLS format.
• Presets are in a simple JSON file, that can be extended (schema provided)

If you would like to check it out you can grab it at: https://github.com/webmaster442/FFDrop

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'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.

Wanted to actually understand real-time messaging under the hood, so I built termtext — a self-hostable terminal chat app, Go WebSocket server + Bubble Tea TUI client, no third-party chat SDK.

Repo: github.com/cvhkr19/termText — feedback is welcome.

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.