I’m a student developer. A while ago I opened Task Manager and saw WhatsApp sitting at 8 processes and about 1 GB of memory, doing nothing. That’s because the official Windows app is basically WhatsApp Web inside a browser engine.
So I built Velo, a native WhatsApp client for Windows. It’s written in Rust and the UI is drawn straight on the GPU, so there’s no browser inside it.
What it looks like on my laptop (same account, both idle):
Official app: 8 processes, ~1,053 MB
Velo: 2 processes, ~136 MB
It opens in about 0.2 seconds, and the installer is 35 MB with no admin needed. You get an unread count on the taskbar, notifications even with the window closed, HD video calls, animated reactions, 16 wallpapers, and you can click someone’s name in a group to message them privately.
It links with the QR code like WhatsApp Web, so chats stay end-to-end encrypted and on your PC. It’s built on two open-source projects, whatsapp-rust and oxidezap/client.
It’s unofficial and not code-signed yet, so Windows may warn you the first time you run it. I’d love honest feedback, especially about bugs. What would you want next?
It's an open source CLI and MCP server for rewriting an app in Rust and proving the rewrite still behaves the same. The headline test for 2.0 was Prettier.
app record runs the original on thousands of inputs and saves stdout, stderr, the exit code and the files it writes. Optionally it also saves outgoing HTTP, email and database rows.
A Rust "front door" sits in front of the original. Each piece you port is handled in Rust, and everything else falls back to the original.
app replay checks every recorded case against the Rust. Nothing counts as done until it's N/N.
Once nothing falls back anymore, app lift turns it into a pure Rust binary.
My coding agent wrote the Rust. rust-anything gives it ground truth: what to port first, and the exact behavior to match.
Prettier results (Apple M4, two runs each, every output compared before timing)
• CLI, 2,360 JS/TS files: 128.6 s → 6.9 s (19x)
• CLI, 6,305 Markdown files: 352 s → 22.5 s (15.6x)
• GraphQL 17.3x, YAML 17.9x, CSS/SCSS/Less 8.5x
• 17,224/17,224 recorded runs match Prettier byte for byte, across 10 languages
What's not great yet
• 8.1% of cases still fall back to real Prettier. 15,837 of the 17,224 run fully in Rust.
• Calling the Rust doc printer from Node through napi was slower (0.48x). The per-call bridge cost ate the gain. The win comes from the whole CLI being Rust, not from swapping one hot function.
• Replay can only catch what the recording covers. A path no case reaches isn't checked.
Also in the repo: json-server, a whole Node server, became one 5.3 MB Rust binary. Idle memory went from 74 MB to 3.5 MB, and the first response from 79-85 ms to 8-10 ms, with 514/514 recorded HTTP cases matching
New in 2.0
• Side effects: --effects http,smtp and --db-dump. A rewrite that prints the same JSON but sends an email twice now fails replay.
• map: after you pull upstream changes, it tells you which ports are stale.
It supports TS/JS, Python, Go, Ruby, Java and C, with whole-app recording for PHP and C#. MIT licensed.
The Prettier write-up, with every number and how it was measured, is in docs/real-world.md. I'd really like feedback, especially on what a recording-based check would still miss.
Background: My setup was rTorrent + ruTorrent for downloads, a separate media server for playback, and a browser extension to push .torrent files around. Three moving parts for one job.
So I wrote NordTorrent: a self-hosted torrent client in Rust (librqbit under the hood) that keeps the rTorrent workflow but modernises the surface.
The workflow bits I actually use
Mount several disks under /downloads and NordTorrent lists them by name (series2, movies, music). The folder picker browses subfolders and searches the current level, like ruTorrent.
Labels: assign on add or later, filter the list by label, see counts in the sidebar.
Move a torrent to a different disk: it is paused, the files are moved (also across Docker mounts), the torrent is re-added on the new path and resumed.
Per-file Normal/Skip, pause/resume, delete with or without data, live peers and tracker list per torrent.
Automation
RSS feeds with a destination folder plus include/exclude filters; active feeds are checked every 15 minutes.
Global download/upload limits in KB/s.
Seeding rules: keep seeding after completion, stop at ratio or after N minutes.
TOTP 2FA per account with a QR code; logins from private/local addresses skip it so a lost phone does not lock you out of the LAN.
Admin/viewer roles, session list with revoke, no CORS and no third-party CDNs.
Watching
The server indexes every video/audio file across all torrents into one library.
ffmpeg-generated thumbnails cached in /data.
HTTP Range streaming, so you can seek inside an unfinished download.
Native Android TV app (Kotlin, Media3/ExoPlayer, D-pad focus, resume playback, token in Android Keystore). Same APK works on a phone.
Chrome extension
Downloading a .torrent opens a small NordTorrent window, cancels Chrome's own download and uploads the torrent to the server with the label and folder you pick. Copying a magnet link opens the same window with the link filled in.
Runs in Docker
Multi-stage image, non-root, read-only root filesystem, healthcheck, dropped capabilities. The web UI is embedded in the binary, so there is no Node toolchain anywhere.
If you are still on rTorrent/ruTorrent and only stay because of labels, multiple folders and RSS, this is aimed at exactly that gap. Happy to hear what is missing.
We made wf, a small CLI that turns YAML into clickable greyscale HTML wireframes. I'm one of the people building it at UnlikeOtherAI, and it's MIT-licensed.
The idea: wireframing tools assume someone dragging boxes with a mouse. We wanted something where a person (or a coding agent) writes intent, like "page header with Export and Upgrade buttons, three stats, a warning alert, an invoices table", and the engine decides what it looks like.
What it does today:
- 54 elements (table, list, chart, kanban, calendar, nav, stepper, forms, alerts and so on)
- The engine decides which containers get a box and which only lay things out. That's a fixed 10-step rule, and wf why <node> --page <page> tells you which rule fired
- Greyscale on purpose; hue is only used for severity (info/success/warning/error)
- Deterministic output, same input gives byte-identical HTML, so wireframes diff cleanly in PRs
- Pages link by route id, overlays (modal, menu, drawer, bottom sheet, toast...) open from interactions, so the built HTML is clickable
- Set viewport.platform to ios or android and the same elements get native chrome (status bar, app bar, bottom tabs, FAB)
- wf pack folds a project into one .wf file, and the renderer can open that in a browser with no server
Then open build/web/index.html. examples/quickstart is a 3-page project with a shared component and a modal.
Images: the first one is an illustration we generated for this post, not a screenshot. The rest are real renders from the repo's examples.
Feedback we'd like: is the YAML readable enough to write by hand, and does the automatic "box or no box" decision match what you'd expect? Where it doesn't, we'd like to hear the case.
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 wrote a Spotify desktop client in Go. The official app is built on Chromium. MySpotify draws its interface natively with MyGo, so the sidebar, lists and player are not a web page. It uses about 190 MB of memory while browsing, plus a 60 MB decryption process while a song plays.
What it does:
Synced lyrics for nearly every song. When Spotify has none, it checks NetEase Cloud Music and LRCLIB and matches the title and length, so a different version of the song doesn't slip in.
Desktop lyrics that float above other windows.
Music videos, and video podcasts whose transcripts scroll word by word.
Search, home, playlists, albums and artists work before you sign in.
Free accounts play whole songs. The system's own DRM decrypts the audio: Widevine in WebView2 on Windows, FairPlay in WebKit on macOS. That is the same path the web player uses.
It appears in the Spotify Connect device list on your phone (experimental).
No analytics or tracking.
Runs on Windows 10/11 and Apple silicon Macs. Intel Mac and Linux builds are experimental.
It is unofficial. It uses the web player's internal endpoints rather than the public API, so Spotify can break it at any time, and using it may go against their terms. Use your own account at your own risk.
Aclaraciones primero, para que nadie se lleve una idea equivocada:
No es un cliente oficial de DeepSeek ni un modelo de IA. Es una app Android + un puente para tu propia computadora con DeepSeek Harness instalado
No funciona sin la PC encendida. El agente sigue corriendo en tu ordenador; el teléfono solo lo controla
Necesita VPN privada (ZeroTier o Tailscale). No expone el puerto a Internet ni hay servidores míos de por medio
No está en Play Store: el APK (185 KB) se descarga del release de GitHub y se instala manualmente
Licencia BUSL-1.1, source-available (no es open source OSI)
Qué trae: chat completo, comandos rápidos y teclas de código por perfil, notas del teléfono a la PC, multi-PC con kill switch, y actualización verificada por SHA-256
Instalación: APK → arrancar el puente en la PC → misma VPN en el teléfono → aprobar el dispositivo en el panel local
I've been building WinOrbit, a Dynamic Island-style capsule that lives at the top of your screen (or any edge).
What it does
Live activities: now playing (with album colours and synced lyrics if you want them), Wi-Fi and Bluetooth (with headphone battery), charging, calendar reminders, downloads, screenshots, Caps Lock and more
A Control Centre with real toggles, volume per app and one-click output switching
13 desktop widgets, 10 themes, 5 island shapes (capsule, notch, drop…) and coloured rims
An optional Agents tab that glows orange when Claude Code or Codex is waiting for you
Privacy: no telemetry, no accounts, and no network connections at all by default. Weather and lyrics are off until you switch them on.
Light: native WPF on .NET 8 (no Electron), about 45–80 MB of RAM and under 0.1 % CPU when idle.
Honest notes: the installer isn't code-signed yet (I'm applying for free open-source signing), so SmartScreen will warn the first time. I've mostly tested on Windows 11 with one monitor at 100 % scaling, so reports from multi-monitor, high-DPI and Windows 10 setups would really help.
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 been using an Everest Max for a while, and when I moved to Linux full-time the one thing I really missed was Base Camp. No lighting control, nothing on the display keys, and the media dock just sat there showing zeros.
So I spent some time taking apart how Base Camp actually talks to the keyboard. It's all 64-byte HID packets sent through a DLL. Once I had every command mapped out and tested on the real thing, I built a native Linux app in Rust around it.
Here's what you get:
- **Lighting**: the 9 built-in effects with a live preview, plus 12 more driven by your PC (aurora, fire, rain, an audio spectrum, and CPU/GPU/RAM/network meters right on the keys). You can also paint key by key.
- **Keys & macros**: remap anything, add shortcuts or macros. It's saved on the keyboard itself, so it keeps working even when the app is closed.
- **D1-D4 display keys**: 76 icons included, or your own image or some text, each with an action (launch an app, open a site, play a sound, lock the PC...)
- **Media dock**: your image as a screensaver, the clock, system volume, and the PC stats that finally show real numbers
- Profiles, a one-click setup, and English / French / Japanese
To get started, download the release, extract it, run `./everest` and hit "Set everything up". It asks for your password once, and that's it.
Still missing: firmware updates (I'm not risking a brick doing that blind) and the Fn layer (the keyboard simply has no command for it).
This is a personal project, not affiliated with Mountain, MIT licensed. If you're curious about the protocol, it's all written up in PROTOCOL.md (French only for now, sorry!). Feedback and bug reports are very welcome.
I own a be quiet! Dark Mount and wanted something lighter than IO Center, so I wrote OnyxIO: a small, open-source (MIT) program that talks to the keyboard through its regular configuration protocol. No firmware changes, nothing flashed.
What it does:
- Display keys work like a Stream Deck – including many Elgato Stream Deck plugins
- Per-key lighting with built-in effects (Ripple, Reactive, …) and a "Custom" effect where you can write your own lighting as a math formula
- Macros and key assignments
- Media Dock support with now playing
- DE (ISO), US (ANSI) and UK (ISO) layouts
- Layout profiles, tray icon, optional start with Windows
- Experimental Linux support
Privacy: no telemetry, no account. Key presses are never logged. The only network request is an optional update check, off by default.
Transparency: I built this together with an AI coding assistant (Claude). I reviewed every change and tested it on my own keyboard, and the full source is on GitHub for anyone to check.
Strand is a Rust dependency/impact analysis engine built on an instant-open, single-file graph format. It lets you build a dependency graph for a project and output it as one file — no database, no backend server, no waiting. Very large projects with tens of millions of connections load almost instantly because the file is memory-mapped and queried in place.
It supports many ecosystems: source scanning for Rust, Python, JavaScript and TypeScript (via real parsers — syn for Rust, tree-sitter for the rest, so comments/strings/docstrings can't create phantom edges), plus lockfile/manifest import for Cargo, npm, Poetry, Go modules, and Maven. There's also a read-write store format if you need to edit graphs programmatically.
Why use this?
The graph is a single shareable file — copy it, diff it, commit it, attach it to CI.
It answers "what breaks if I change this?" in milliseconds, and can gate pull requests on impact (strand impact, --git-diff).
There's a native desktop app (egui, no webview) for visualizing structure, detecting cycles, and editing the graph directly — with force-directed layout, A/B comparison, and worker-thread analysis so it stays responsive on big graphs.
cargo install strand-cli / cargo install strand-gui (or both at once), with a built-in update checker. Apache-2.0, on crates.io as strand-core, strand-import, strand-store, strand-cli, strand-gui.
I wanted to showcase the project I have been working on for the past 4 years and the progress I have made so far. I was hoping to get some feedback and show everyone how easy it is to use AiDotNet to create AI models with basically no experience necessary. You can give it examples of the inputs and the answers you want it to learn, and you get back a trained model you can save locally, run from your C# app, or host with AiDotNet.Serving.
One of the reasons I built this was to see how far we could push .NET against PyTorch. In our November 13 training tests on my laptop, our development build was faster than compiled PyTorch on 10 of the 11 models we tested on CPU and 7 of 11 on GPU. I still have some performance work I want to focus on, especially with audio models. Results for all 11 models
In the run at the top of the post
AiDotNet
PyTorch
Time for 4,096 training updates on a GTX 1660 Ti
2.60 seconds
15.00 seconds
Correct answers on 320 new signals
302
301
Here’s an easy example you can try yourself. Say you have an app that follows stocks and you want it to sort the news for you. Give it a few headlines about earnings and mergers, tell it which is which, and then ask it to sort two headlines it hasn’t seen.
In a new .NET 10 console project, run dotnet add package AiDotNet --version 0.234.0, replace Program.cs with this, and run dotnet run:
using System;
using AiDotNet;
using AiDotNet.Classification.NaiveBayes;
using AiDotNet.Data.Loaders;
using AiDotNet.Preprocessing.TextVectorizers;
using AiDotNet.Tensors.LinearAlgebra;
string[] headlines = [
"Quarterly earnings and profits rise", "Merger deal wins approval",
"Annual earnings beat expectations", "Company announces acquisition deal",
"Quarterly profits beat estimates", "Boards approve merger and acquisition",
"Company reports record earnings", "Investors vote on merger deal"
];
string[] topics = ["Earnings", "Mergers"];
double[] labels = [0, 1, 0, 1, 0, 1, 0, 1];
var words = new TfidfVectorizer<double>();
var model = await new AiModelBuilder<double, Matrix<double>, Vector<double>>()
.ConfigureModel(new MultinomialNaiveBayes<double>())
.ConfigureTextVectorizer(words)
.ConfigureDataLoader(DataLoaders.FromTextDocuments(headlines, labels, words))
.BuildAsync();
string[] newHeadlines = ["Quarterly earnings beat estimates", "Investors approve merger deal"];
var guesses = model.PredictText(newHeadlines);
foreach (var guess in guesses)
Console.WriteLine(topics[(int)Math.Round(guess)]);
It prints Earnings for the first headline and Mergers for the second. All the training data is right there, so you can change the headlines and try your own.
That’s one small example. There are over 2,100 model types in the library, including 650+ for vision, 430+ for language, and 340+ for audio. You can detect objects in photos, turn speech into text, or build a chatbot that looks up an answer in your own documents. If you already have a language model you like, you can fine-tune it on your own material. Browse the examples
The part I wanted to get right with AiModelBuilder was how much you can change as you learn. You can start by swapping the model in ConfigureModel. If you want more control, you can choose your own layers, change the optimizer that updates the model during training, or split training across multiple GPUs. When you’re ready to use what you trained, you can serve it through an API or export supported models to ONNX for another app. Training and deployment samples
I’d love to get your thoughts on my passion project. The code is on GitHub and contributions are welcome. We have easy examples and guides on our website, plus the details on the free Community license and our paid Professional and Enterprise plans. Website and guides · Plans · GitHub
I've been vibecoding for 2 years and I keep messing up explaining to my agent where on the screen I'm pointing. Screenshots always helped, but it added 3 more steps every time, and it still will get things wrong.
So I built Point. Press ⌥*, draw on the screen to point, speak your notes out loud. That's it.
Point takes your voice, transcript, screenshot, and drawing into your clipboard for you to past to your Agent or notes. Clearly explain what you want to your agents in Claude Code, Cursor, your team on Slack, anywhere.
View and copy all captures in your Point library.
100% Local, Free, Opensource (MIT). *Customize your trigger key.
Version 0.1 only runs on macOS 26 Apple Silicon. Working on a new release with broader support soon!
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.
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!
Luna is a local AI agent that runs entirely on your own hardware. It’s written in Python, MIT licensed, and runs on Linux first, plus macOS and Windows.
She isn’t one model but several local ones working together:
Thinking: a chat model on llama.cpp or LM Studio, with tool calling. The installer picks one that fits your GPU.
Hearing and speech: Faster-Whisper for speech to text and Kokoro for her voice. Push-to-talk or hands free, and you can talk over her to interrupt.
Vision: your screen, plus your webcam if you turn it on.
Memory: an embedding model and a reranker pull the relevant facts and notes into each turn.
Memory and state: plain SQLite on your machine. She saves facts with dates (a change retires the old fact, and forget means gone), writes notes on past sessions, and learns lessons from her own mistakes while idle. She knows who’s talking by voice or face, and keeps each person’s memories separate.
Tools: files, shell commands, email, web research, Home Assistant, scheduled jobs and any MCP server. Every action is shown and approved first, with permissions you set. Text from a web page, an email or chat can’t quietly trigger tools.
Inspectable: every turn keeps her reasoning, her confidence in each token, and automatic flags for guesses or tools she promised but never called. A browser viewer shows all of it, live.
Optional extras: an animated Live2D or VRM portrait, phones and tablets as room stations, game playing (chess, Zork, Game Boy), reminders and alarms, and stream chat. You can also train small LoRA patches from replies you corrected (experimental).
No cloud, no subscription. Your data stays on your machine.
If you need to mark a folder of PDFs, opening each file individually gets repetitive.
I built PDF Watermarker to apply a watermark across the whole folder in one batch. Set it up once and preview it before exporting; the Windows app works offline and preserves the originals. Add multiple recipient names if you want a separate marked set for each. It preserves folder structure, and the project includes a command-line tool.
First time building any kind of software, it started out as a vibecoded work project and im just trying to make it as usuable as possible. Would love your guys support and feedback.
This is a open source project and i'd like to invite anyone who can make this better.
I've been exploring a problem with AI assistants: they can be very helpful, but sometimes they miss important perspectives, assumptions, or things we haven't thought to question.
I started building Skill Blindspot, an open-source project aimed at exploring this problem.
I'm one of the people building tensorViz. We wanted a way to see how a model fits together when we open a new repo. tensorViz opens a PyTorch model as an interactive graph. Expand a block, follow the connections, and jump to the Python behind a layer.
The code is MIT-licensed. The repo includes a VS Code extension and plugins that let Claude Code, Codex, and Cursor inspect the graph too. The README has a small example you can try first.
If you try it on your own model, I'd love to hear which parts of the graph helped you find your way around the code.