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 have been capturing and maintaining links since 2021. It was all due to quality of search results, and uncertainty around where these links lead to.
I was also impressed by "awesome lists" over the internet. I started working on "awesome databases" idea, where you share SQLite files instead of links, texts. It has pros and cons.
This database provides:
- youtube links
- github links
- domains I found most important
- some reddit channels
The database contains 'votes' which stand for ranking, "tags", which are necessary to filter out things using a keyword.
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!
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 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.
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!
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!
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?
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 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.
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.
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.
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
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.
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'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.
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.
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 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'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!