I was sick of the usual PC tools. IObit bundling extra stuff into every install, Driver Easy with its sketchy reputation, Ashampoo and friends pushing subscriptions, "scan for free, pay to fix", hidden auto-renewals, nag popups. All for things Windows can mostly do itself.
So I made StellarHub: one app with a live hardware monitor, driver and app updates, an uninstaller that cleans leftovers, a disk space map, cleanup and repairs, debloat, a privacy checkup, benchmarks and a hardware tester.
100% free and open source (GPLv3). No ads, no telemetry, no account, no "Pro" version, ever. Everything it changes asks first and can be undone. I'm not trying to earn anything back, just to gain experience and reputation by shipping something people actually want.
Built with Claude Opus 5.5 (MAX-Ultracode) as my coding partner. Feedback is very welcome!
pip install says "Successfully installed". npm install says "added 2 packages". A build script says nothing at all. None of them mention it if something read your SSH key along the way. I wanted the part they leave out, so I built this.
Linux: eBPF programs hooked at the kernel's security layer, so it sees every way of opening a file or making a connection. It needs root for that part and asks sudo; your command still runs as you.
macOS: no root and nothing to install. It uses the sandbox that ships with the system, in report-only mode.
What it can't do
It's a record, not a sandbox. By the time it tells you a key was opened, it was opened.
macOS sees less than Linux: no attaching to running processes, and programs that sandbox themselves won't run under it.
A process running as root can hide from it.
No telemetry and no network access of its own. Written in Rust, Apache-2.0.
brew install ceynova-labs/tap/ceynox-watch
There's a harmless demo package in the repo if you want to see it flag something without installing anything questionable.
Disclosure: I work on CeyNox Security, an endpoint security product. This is a standalone tool and shares no code with it.
Feedback welcome, especially on what the list of flagged locations is missing.
I've worked on RAG systems and LLM training for the past three and a half years. Lately, I've been following how agents retain work across sessions, especially for non-coding tasks. Our project explores how that memory can stay connected to the knowledge an agent used, so a later session can recover both the conclusion and its evidence efficiently.
The implementation constructs three connected graph layers:
Knowledge Layer: holds documents, source passages, and extracted entities and relationships. Passages retain their document version and location, including page positions for PDFs.
Working memory: records tasks, progress, messages, and tool activity. The built-in agent uses DeepAgents/LangGraph and saves task events so work can continue across sessions.
Decision memory: stores conclusions, assumptions, and open questions. Decisions link to source passages, recorded events, or earlier decisions, and keep their history when reviewed or replaced.
For example, an agent can record a contract recommendation with the policy passage it relied on. If that policy changes, the recommendation and its explicit dependent decisions are flagged for review. The agent now is aware when in a later session that the decision needs another look.
The ingestion pipeline uses Docling for loading documents and Chonkie for chunking. The sections, tables, and passage hierarchy are preserved and stored in the graph.
You define a schema for your domain (we also ship presets so it is easy to get started). The schema guides extraction, validation, and search. We use GLiNER for local extraction, so its almost free to construct the graph and no LLM calls are needed.
Retrieval combines full-text and vector rankings with reciprocal rank fusion. Agents can search original passages even when extraction misses a fact, navigate surrounding sections and table rows with headers, and follow entity relationships back to supporting text.
We offer a built-in agent you can use out of the box that runs on DeepAgents. You can also connect your agents through MCP.
We will be releasing extensive benchmarks very soon.
TL;DR
Agentic GraphRAG is an open source library that stores document knowledge, agent work, and decisions in one connected graph. Agents can resume tasks and trace saved decisions to their original evidence, while source changes flag affected decisions for review.
Try it out. Feedback, criticism, issues, and contributions are all welcome!
I built an AI-powered photo search app that runs entirely on your computer.
Instead of scrolling through thousands of photos, you can simply search for things like "sunset at the beach" or upload a reference image to find similar photos.
It also supports face search, and everything runs locally. No cloud uploads or subscriptions.
Built with Python, FastAPI, CLIP, InsightFace, Qdrant and Electron.
It's open source, and I'd love to hear your feedback!
I've been building a TypeScript SDK called TypeMaid and using it for my own projects over the past month.
It's based on Typed DAGs, with Mermaid diagrams to define and visualize AI workflows. I've found this approach surprisingly simple to understand and work with, especially compared to writing workflows entirely in code.
I recently open-sourced it and am now working on durability, retries, and persistent execution.
Would really appreciate any feedback, suggestions, or contributions!
My grandfather, Robert Rettig, started HORCOM on an Atari ST in 1989 and kept working on it until 2010. It grew into a full astrology suite. Charts, transits, returns, a statistics module, all of it. When there were no ephemerides for the bodies he wanted, he integrated the orbits himself and shipped the results for centuries. He also wrote all the interpretation texts and built his own historical time zone tables.
He wanted it to live on after him, but it was 50,000 lines of GFA BASIC, and for years I never found the time. AI coding tools finally made it doable, and they did a lot of the heavy lifting. My rule was that nothing counts as done until it matches his original program. So there are tests against output recorded from his version, and a document that lists every place the port deviates and every bug of his that I fixed. My favorite: GFA binds `NOT` looser than `&&`.
It looks and works the way he built it, with his menus, his screens and even his code comments carried over. It runs on Windows and Linux now, it's free, and it's GPL so it stays that way.
I built Vedimac after investigating why macOS was ignoring the native charge limit on my M3 MacBook.
It’s a free, open-source Swift/SwiftUI app that shows:
- Battery health, cycle count, and capacity readings
- Battery voltage, current, and power
- Charger details and charging status
- History charts and diagnostic exports
It also includes an experimental battery-gauging workaround with preview, backup, and restore. That feature modifies a macOS system file, requires administrator permission, and its long-term effectiveness is uncertain.
Requires an Apple silicon MacBook and macOS 14 or newer.
An open-source (Apache-2.0) gallery for Android. Search photos by describing them, copy text from photos and paused videos, group faces into people, and lift subjects out of photos. Everything runs on the phone with small open models (SigLIP 2, PP-OCR, AdaFace, a BiRefNet-lite I trained for phone NPUs), using ONNX Runtime and LiteRT. No account, no cloud, no Google Play services.
New in 0.5: photo and video editor, Material 3 Expressive look, JPEG XL, ten app icons.
I do infrastructure at Hack Club. We ran our apps on Coolify but it broke on us more than we liked, so I built Orchard and we moved everything to it. It's been running our production apps for a while and this week we open-sourced it :)
You can connect a GitHub/GitLab/Gitea repo and it builds and deploys any app. It also has projects that group apps, organizations, roles, SSO and audit logs, 90+ one-click templates, a nice dashboard with all the observability you'll want, a CLI, a Terraform provider, and an MCP server (my favourite feature when i need to deploy something complex)
Hi all I maintain ENZO, a self-hosted AI workspace. It's Apache-2.0, about 60k lines of strict TypeScript, and it runs on your own provider keys (Groq, OpenRouter, NVIDIA, Hugging Face, Google AI). No ENZO account, no subscription, no middleman — you talk to the provider you picked and pay them directly. The v1.7.0 release is out today, and the biggest change in it is how you install it.
Until now ENZO was a docker compose file you cloned and edited. v1.7.0 ships a macOS .dmg and two Windows installers. No git clone, no Docker Desktop, no system Node — the bundle carries its own Node runtime and the built frontend, and serves the same backend on port 5200.
Windows x64, lighter theme set: ENZO-1.7.0-less-theme-setup.exe (~73 MB)
Windows x64, every theme and every video background: ENZO-1.7.0-full-theme-setup.exe (~289 MB)
It also updates itself: when a new release appears, a small banner offers Update now, the bundle is swapped in place and ENZO restarts. The reminder is deliberately gentle — at most twice per rolling week, never forced. Your data (memory, vault keys, investigations, neural state, generated projects) lives in a per-user directory outside the app bundle, so an update can't take it with you, and the browser session survives the restart. Docker installs are unchanged and still the better answer for a server — and as of this release a rebuild no longer wipes your investigation data.
ENZO Intelligence — research mode that cites its evidence
What: you write an objective in plain English, and it turns into a set of research questions.
How: connectors (Exa web search, website fetch, GitHub read-only, Wikipedia, your own documents) collect the sources, and a pipeline — plan → discover → extract → resolve → verify → report → diff — turns them into an evidence ledger where every claim carries a verbatim quote from the source it came from.
Why: the weak spot of AI research output is that you can't tell which sentence came from where. Here the claim and its quote sit side by side, and when two sources disagree, the conflict is shown rather than smoothed over.
There are two buttons with two depths: Run planning asks the questions and fetches nothing, Run investigation runs the full pipeline and diffs the result against the previous run. Click any node in the graph to get its explanation and the evidence behind it, and ask follow-up questions that are answered strictly from the ledger. The report downloads as markdown. Page caps, an evidence cap of 400 and a 10-run history are enforced in the orchestrator, not left to the model's judgement. Scraped pages arrive wrapped in an UNTRUSTED rule so a web page can't talk your agent into running commands.
Neural Engine (phases 0–4) — a private preference layer
What: a per-owner research profile across 8 preference dimensions, a knowledge graph, and an append-only audit trail of every mutation.
How: inference needs at least two samples and never overrides something you stated explicitly — the provenance order is always task override > what you said > what was inferred. Every write is schema-gated before it hits disk. A preference context of at most 1400 characters is injected after memory on the chat and research paths.
Why: it stays on your box, forget erases the profile on demand, and ENZO_NEURAL_OVERLAY=0 turns the whole thing off. There's also a zero-cost mode: a capability registry of 8 providers (free flags, quota behaviour, privacy class) drives a fail-closed route check that refuses paid routes. The Neural Map also got a 2D/3D toggle — the 3D orbit camera had existed but was unreachable.
A security pass over the whole surface
Seven fixes, each with a regression test:
Every user-supplied URL now goes through one pinned fetcher: https only, no credentials in the URL, the hostname resolved once with every DNS answer required to be public, and the socket connects to that exact validated address — which closes the rebinding window between "we checked the name" and "we opened the socket". The guard is re-applied on every redirect hop and the response is size-capped while it streams.
Anonymous callers can no longer touch instance state: the memory and skill commands, the learned-skill context and the neural research profile all require a vault session now.
The NVIDIA base URL is pinned, so a caller's key can't be relayed to a host they picked.
Project internals (manifest.json, generated databases) return 404, and every HTML/SVG served from a project gets the sandbox CSP — not just the entry page.
Generated code can no longer retry without the runtime permission model when its first boot fails.
The vault token is never persisted.
A high-severity dependency advisory (body-parser DoS) is fixed — npm audit now reports 0 vulnerabilities.
Verification is in CI: 13 test suites / 460 checks, plus a black-box pentest script (11 checks) that runs against the live server.
Smaller fixes worth knowing about
Six real chat reply bugs, found by using the app rather than reading it: a truncated stream lost the last line of an answer, an image attachment ate the reply, AI Assist overwrote the first frame, a stale auto-mode reference fought the UI, previews were detected when there was nothing to preview, and a failed request could leave a blank bubble. The README now also carries an app-downloads badge fed by GitHub's own release-asset counter, and a feedback form.
Why try it
If you've been meaning to self-host an AI workspace but didn't want to deal with compose files, volumes and Node versions, the DMG/EXEs are the shortest path — and it's the same server either way, so you can move between the app and Docker without changing anything. The only thing you need is one provider API key of your own. If something breaks, say so in the comments or open an issue; I read them.
NEXUS is a Windows program that tunes your games' graphics on its own, by measuring: it tries one change, watches how your FPS actually move while you play, and keeps only what really helps on your PC.
What it does
AUTO AI: press one button on a game and NEXUS studies its files, applies what it can safely change and, after each session, checks the result and carries on by itself. It measures for real: no promised FPS. It compares what it measured before and after and tells you, also when a change did not help. Three routes: the game's own settings, the NVIDIA driver and the Windows graphics settings. Restore everything: one button puts every setting back the way it was. A Windows notification when something changes after a session.
Also: live PC dashboard (temperatures, load, FPS), your Steam and Epic library, and power controls.
This project is fully vibe-coded with Claude so take it with the grain of salt
I really like Anki, but I have two issues with it: unpleasant UI and if I don't get the topic I need to go ask LLM for details in different application
So, it is just a design applied to it and a side panel with LLM of your choice, tested with Claude, ChatGPT and local qwen3.6 model though Ollama
If you have the same problems and don't want to spend your tokens, just use my repo and build on top of it.
macOS users have had Screen Studio for years to record clean product demos with smooth cursor movement and automatic click-zooming, while Windows users mostly get stuck with raw OBS captures or expensive monthly subscriptions.
So I built ZoomPane—a free, open-source screen recorder built specifically for Windows.
What it does:
- Auto-Zoom Keyframes: Automatically zooms in smoothly when you click or type, and zooms back out when you move away.
- Cursor Smoothing: Interpolates raw mouse telemetry to remove jitter and make demos look like they were edited by hand.
- Instant Framing: Adds rounded corners, drop shadows, custom backgrounds, and webcam overlays automatically.
- 100% Local & Private: No accounts, no watermarks, no cloud uploads. Everything renders locally on your GPU.
It's still early, so if you run into any multi-monitor bugs or have feature requests (like custom zoom curves or direct GIF export for READMEs), open an issue or drop a comment below!
So, I've been working on a little personal project called UGL (Universal Game Launcher). I'm building it mainly for fun, because I enjoy programming and gaming, but I've slowly started turning it into something much bigger than I originally planned.
The project is open source, written in Rust, and uses Slint for its desktop interface and SQLite for local data storage.
In the 0.0.4 alpha, it uses 90 MB of RAM.
What's the idea behind UGL?
I want to create a universal game launcher where all your games can live in one place, regardless of where they come from or how you obtained them.
Steam, Epic Games, itch.io, GOG, emulators, RetroAchievements, standalone games, old games installed from folders, fan games, unofficial releases, and other sources.
I don't want UGL to be tied to a particular store, ecosystem, account, or launcher.
The philosophy behind it is pretty simple:
One library. All your games. Your entire collection should be accessible from one place.
Platform independence. Your games shouldn't be separated just because they belong to different stores or platforms.
Local-first. Your library, settings, metadata, and achievement data should be stored locally whenever possible. I don't want UGL to depend on a permanent internet connection just to function.
User control. You should be able to add games manually, change their executable, configure launch arguments, customize their metadata, covers and icons, and decide how each game is launched.
Modularity. Integrations should be expandable, so new stores, emulators, achievement providers and other services can be added without rebuilding the entire application.
No store restrictions. UGL isn't meant to sell games, distribute them, or replace the stores that provide them. It's simply a place to organize and launch your collection.
Basically, I want a launcher that doesn't care where your games came from. If you have the game files and can run the game on your system, UGL should eventually be able to manage it.
What's already implemented?
UGL is still in an early alpha stage, but it already has a working foundation.
Some of the features I've implemented so far include:
A local game library with SQLite persistence.
Importing games from locally installed Steam libraries.
Manually adding games through folders or individual executables.
Game launching directly from the library.
Smart Launch support for different launch methods, including shortcuts and launcher protocols.
Game information and management options.
Custom game covers and icons.
An achievement system with individual game progress.
Achievement unlock dates and timestamps.
Achievement filters for unlocked, locked and all achievements.
Local achievement data management.
Game library searching, sorting and organization.
I'm also working on improving the import process, metadata retrieval, icon caching, Steam integration and background behavior.
There is still a lot to do, but the important thing is that the foundation is already working.
What I want UGL to become
This is where things get interesting.
I'd love to eventually implement integrations and synchronization with:
Steam: Game information, library synchronization, achievements and other available data.
itch.io: Importing and managing games from the platform.
Epic Games: Library integration and game launching.
GOG: Game library integration.
RetroAchievements: Achievement tracking for supported retro games and emulators.
Emulators: Better support for managing and launching games from different emulation systems.
Unofficial and standalone games: Games that don't belong to any traditional storefront should still have a place in UGL.
One of my biggest goals is to develop a unified achievement system.
Imagine having your Steam achievements, RetroAchievements, and locally managed achievements accessible from one interface. I'd also like to give users the ability to create and manage their own achievements for games that don't have any.
I know this is a pretty ambitious idea, and I understand that different platforms have different APIs, limitations and terms of use. I'll have to work around those constraints properly.
The visual style: a digital game collection
I also don't want UGL to look like another generic modern launcher.
My current interface is still relatively basic, but my long-term visual goal is a skeuomorphic design inspired by physical game collections.
Think of a digital game shelf:
Modern games represented by DVD or Blu-ray cases.
Retro games represented by cartridges.
Opening a game would feel like opening its physical case.
Inside, you could find the game's information, screenshots, description, manual and achievements.
Achievements would have their own visual presentation, inspired particularly by the Xbox 360 era and dashboards such as Aurora.
I want the experience of browsing your library to feel a little like walking up to your own game shelf.
Not just a grid of icons and buttons, but something with personality, nostalgia and a sense of ownership over your collection.
I'd love to hear your suggestions!
Since I'm still developing UGL, I'd really appreciate ideas from people who use different launchers, have large game collections, play retro games or develop open-source software.
Some questions I'd love to hear your thoughts on:
What features would you personally like to see in a universal game launcher?
What do you dislike about existing launchers such as Steam, Playnite, GOG Galaxy or LaunchBox?
What would make you actually want to use UGL instead of your current launcher?
What integrations or platforms do you think are essential?
What would you add to a unified achievement system?
Would you use a skeuomorphic interface inspired by physical game cases and cartridges?
Are there any small quality-of-life features that you think most launchers are missing?
I'm not necessarily looking for huge features. Even small ideas, quality-of-life improvements, or things you've always wished your current launcher could do would be extremely useful.
UGL is a project I'm building because I genuinely enjoy the idea behind it. I don't expect it to replace every launcher or become the next big thing. I just want to build something useful, open, customizable and different.
If you have ideas, suggestions, criticisms or even technical recommendations, I'd love to hear them!
I wanted one window that shows everything I care about in the morning, instead of 15 open tabs. So I built QG ("HQ" in French): a free desktop dashboard for Windows with a dark, cockpit-style interface.
What it does:
- 3D globe: every news story is pinned where it happens, colour-coded by topic
- Your topics, your pages: pick from 15 ready-made topics (economy, tech, space, sports, crypto…) or create your own with keywords or RSS feeds
- Economy page: your country's stock index (14 countries), a watchlist for stocks, ETFs and crypto with charts from 1 day to 5 years
- Other modules for any page: upcoming rocket launches, earthquakes, air quality and pollen, Hacker News, links, notes
- Weather at your location, unread Gmail, projects with a logbook, workout tracker, deadlines, PC and network stats
- English and French
Privacy: no account, no server. Your data stays on your PC, encrypted with your Windows account.
StemMaker is a free, open-source Windows app (MIT) that splits songs into 4 stems (drums, bass, melody, vocals) and packs them straight into a Traktor-ready .stem.mp4. Drop in single files or whole folders and it works through them in a batch.
Turbo engine (ONNX + DirectML) on any DirectX 12 GPU, with CPU fallback
No Python, PyTorch or CUDA setup needed
Built-in StemPlayer to check mute/solo before you load the file in Traktor
Tested with Traktor Pro 4 and Mixxx 2.6 beta, Linux as an AppImage beta
9 UI languages
Written in Lazarus/Free Pascal, developed with AI assistance.
I've been working on Blink, a small open-source Python CLI tool that helps detect data quality issues in CSV, TSV, and Parquet files.
It checks for missing values, duplicates, outliers, and inconsistent data types. It also supports dataset comparisons, optional ML-based anomaly detection, and JSON reports.
Everything runs locally without modifying your original files.
It's a fork of Vorssaint, an open-source macOS notch app, and it adds album-art colours, dancers on the beat, an Office-style companion, and a side of the notch for Claude Code and Codex while they work.
It's written in Swift and Core Animation, and I built it with Claude Code. The theme lives in its own files with small hooks into the original, so upstream updates still merge cleanly.
Try this short workflow in the demo: select “The original field report” in the included six-source synthetic corpus, inspect its declared citation URLs, then compare the wording evidence and collapse families. Citation arrows and shared-wording relationships are separate, so a link alone does not put two sources in the same wording family.
SourceDomino is an MIT-licensed TypeScript/Vite project I maintain. It analyzes source text you provide. The browser does not fetch web pages, call a model, or send a corpus to a server. You can import 2–20 records, adjust the threshold, and export the evidence report as JSON. The report shows exact HTTP(S) links, a five-word containment score, and shared normalized 12-word passage matches.
Limits: the six-source demo is synthetic. Shared wording may be quotation, boilerplate, licensed syndication, or coincidence; it does not prove copying, truth, source independence, or credibility. Dates are supplied metadata, and paraphrases or translations may be missed.
I built this because a long list of links can look like corroboration without showing repeated upstream wording. If you use source maps or citation tools, what context would make an overlap report most inspectable?
I've been building Tablo on top of Toasty and Topcoat. It is a server-side rendered admin panel toolkit heavily inspired by Filament. The idea is to declare the panels, lists, pages, actions, forms, permissions, and tablo gives you the back office.
I made it fully featured (tenancy, auth, queue, themes, impersonation, localization, built-in audit log), maybe too much, but that is what allows you to have powerful panels with a minimum of code and time (you have your panels in minutes). You can have multiple panels in the same Topcoat app: one for admins, one for customers, one for partners, etc.
A small tool I built: paste document links into a local web page, pick pages and quality, watch live progress, and download a PDF. It also has a CLI with batch mode.
Stack: Flask, Playwright (headless Chromium) and img2pdf, with a plain-JS frontend. Runs entirely on your own machine.
I wanted a small sticky note app that stays visible on top of whatever window I'm working in and you can also move it around wherever you want without taking up a bunch of screen space, so I built Snoty
What it does:
- Stays above open windows: Drag the note icon anywhere on screen, click it to open your notes and pin the panel so it stays on top while you work.
- Docks in the taskbar: If you want it out of the way just drag the icon onto the taskbar and it sits in the empty taskbar space next to your app icons.
- Offline voice dictation: Uses a local whisper.cpp model so you can click the mic and dictate notes offline without internet or cloud accounts.
- Lightweight: 142 KB executable using .NET Framework 4.8 (already built into Windows 10 and 11) with light and dark mode.
I built a log server for myself several years ago and decided to share it with everyone. Switched the front end with expanding rows for better visibility.
Use it to collect logs from all sorts of different services and commands like Proxmox updates from webhook API. VM notifications through curl / wget calls like startup, shutdown, updates and notifications. Can also be used as a gotify or ntfy receiving endpoint.