value: Get personalized guidance, instant explanations, and adaptive practice that fits your learning style. No more struggling alone — Master Any Subject with your always-available AI study partner. Start free today—no credit card required.

value: Show HN: Personal AI Tutor – Available 24/7


value: ianberdin

value:
Hi HN,
I’m a solo founder (currently running PlayCode.io). For the last few years, I’ve been battling a specific kind of burnout: the loneliness of having no one to think with.
I have friends and a wife, but they aren't in the trenches with me. I tried using ChatGPT and Claude as "sounding boards," but I hit a wall: Amnesia.
Every time I opened a new chat, I had to re-explain my context, my values, and my history. It felt like explaining my life story to a new stranger every day. It was exhausting. I didn't need a code generator; I needed a partner who knew me.
So I built Partner.
What it is: Partner is an AI cognitive companion designed for "active debuggers" - founders and creators who are trying to debug their own psychology and decision-making processes.
How it’s different: Most AI memory is just a vector database of facts. Partner is built around a "Living Constitution".
It doesn't just remember "Ruslan likes coffee."
It remembers principles we've agreed on (e.g., "I have a tendency to over-engineer," "My goal is freedom, not just revenue").
It proactively uses this context to check me. If I say "I'm going to build X," it might say, "Wait, last week we agreed that X is a distraction from your main goal. What changed?"
The Tech:
Memory Architecture: Instead of raw RAG, it uses a structured memory system (Insights, Patterns, Decisions) that acts as a long-term operating system for my brain.
Psychotherapeutic Inquiry: It’s prompted not to give advice (unless asked), but to ask the "one question" that peels back a layer. It helps me find the root cause, rather than just patching symptoms.
Deep Context: It holds the "full picture" of my life, business, health, relationships, because they are all interconnected. A fight at home affects my deployment; a failed deployment affects my sleep. Partner sees the whole system.
Why I built it: I built this to save myself. I needed a co-founder who doesn't sleep, doesn't judge, and remembers every lesson I've learned so I don't have to learn them twice. It has helped me navigate burnout, fix my sleep schedule, and make harder business decisions.
It’s currently in beta. It’s not cheap (because high-context AI isn't cheap), but if you’re a lonely founder trying to keep your head straight, it might be for you.
I’d love to hear your feedback.
https://getpartner.ai

value: Show HN: Partner – An AI co-founder that remembers you

author: ianberdin


value: linearAmend

value:
Show HN: ReFlow Studio – Local AI video dubbing and censorship
Hi HN,
I am the creator of ReFlow Studio, an open-source (MIT) desktop "uni-tool" for video creators. I built this because I wanted a way to handle the tedious parts of video editing—transcribing, dubbing, and censoring—locally, without relying on expensive, privacy-invasive cloud APIs.
What it does:
* Local Dubbing: Uses OpenAI Whisper for ASR and Coqui XTTS v2 for voice cloning. It is optimized for "Hinglish" (Hindi + English) content.
* Auto-Censorship: Uses NudeNet (ONNX) to find and blur NSFW content in video frames and "bleeps" profanity in audio files.
* 100% Offline: Once installed, no data leaves your machine. This was a priority for creators working with sensitive content.
Technical Challenges:

  Distribution: Packing 5GB+ of AI models into a downloadable installer was a nightmare. I ended up using a split-binary Inno Setup approach to keep the download stable for users with limited bandwidth.

  UI Persistence: I just hit v0.3.1 which finally integrated a settings manager so the app remembers your theme (Light/Dark) and processing preferences between sessions.

  Performance: Managing the handoff between transcription, translation, and rendering threads without locking the main UI thread in Python.

I am currently planning v0.4, which will include "Smart-Silence" removal to automatically tighten up dubbed audio.
I would love to get your feedback on the architecture, the offline distribution method, or the performance of the local inference!
GitHub: https://github.com/ananta-sj/ReFlow-Studio
Thanks for looking!

value: Show HN: ReFlow Studio – An offline tool to dub, translate, and censor videos

author: linearAmend


value: dsifry

value:
I've been using Claude Code heavily, and kept hitting the same issue: the agent would push changes, respond to reviews, wait for CI... but never really know when it was done.
It would poll CI in loops. Miss actionable comments buried among 15 CodeRabbit suggestions. Or declare victory while threads were still unresolved.
The core problem: no deterministic way for an agent to know a PR is ready to merge.
So I built gtg (Good To Go). One command, one answer:
$ gtg 123
OK PR #123: READY
     CI: success (5/5 passed)
     Threads: 3/3 resolved
It aggregates CI status, classifies review comments (actionable vs. noise), and tracks thread resolution. Returns JSON for agents or human-readable text.
The comment classification is the interesting part — it understands CodeRabbit severity markers, Greptile patterns, Claude's blocking/approval language. "Critical: SQL injection" gets flagged; "Nice refactor!" doesn't.
MIT licensed, pure Python. I use this daily in a larger agent orchestration system — would love feedback from others building similar workflows.

value: Show HN: I built a tool to assist AI agents to know when a PR is good to go

author: dsifry


value:
I spend a lot of time in the terminal and wanted a simple way to listen to TIDAL without switching contexts, so I built ttydal. It’s a terminal-based TIDAL client written in Python that uses MPV for playback.
The project was inspired by sqlit (https://github.com/Maxteabag/sqlit). ttydal supports browsing, fuzzy search, and basic playback controls.
This is also my first real Python project, so it’s still small and a bit rough around the edges, but it’s open source and easy to experiment with. I’d really appreciate any feedback, suggestions, or criticism.

value: Show HN: I made a TIDAL client that runs in the terminal


value: justvugg

value:
Hi everyone,
I added skills to PolyMCP to handle a common problem with MCP servers: once the number of tools grows, feeding raw schemas to agents becomes messy and inefficient.
Challenges we faced:
 • Agents consume too much context/tokens loading raw schemas.
 • Tool discovery becomes noisy and hard to manage.
 • Different agents need different subsets of tools.
 • Orchestration logic leaks into prompts.
PolyMCP introduces skills — curated, structured sets of tools with documentation, organized so agents can consume only what’s relevant.
PolyMCP handles tool organization, letting agents with Ollama,OpenAI and more to focus on execution.
Example: generate skills from a Playwright MCP server in one command:
polymcp skills generate --servers "npx @playwright/mcp@latest"
Benefits of skills:
 • Reuse capabilities across multiple agents.
 • Keep agent context small while scaling the number of tools.
 • Control what each agent can access without modifying the agent itself.
Repo: https://github.com/poly-mcp/Polymcp
Would love feedback on approaches for tool organization and minimizing context/token usage in multi-agent setups.

value: Show HN: PolyMCP – structured skills from MCP tools for efficient agent usage

author: justvugg


value: edurevilla

value: Show HN: FileMason – Automate file organization on macOS with custom rules

author: edurevilla


value: neuroosgenesis

value:
NUASM is a universal assembler that lets you write low‑level code in 51 human languages — including Hindi, Japanese, Spanish, Arabic, Quechua, Basque, Swahili, and many more.
No transpilation.
No DSL tricks.
No “English‑only mnemonics”.
Just real assembly, expressed in your own language.
NUASM is built in pure Python and outputs real x86‑64 machine code. It includes:
51 language packs (with dialects and regional variants)
Kids Mode for teaching low‑level concepts
Localized error messages
A universal tokenizer and encoder
Support for bootloaders, kernels, and low‑level systems
A fully documented wiki with examples in every language
The goal is simple:
If you can speak it, you can program it.
Repo: https://github.com/cyberenigma-lgtm/NeuroUniversalASM (github.com in Bing)
Happy to answer questions, discuss design decisions, or help anyone build new language packs.

value: Show HN: Why Should Assembly Be English‑Only? Nuasm Adds 51 Human Languages

author: neuroosgenesis


value: diginova

value: Show HN: Curated index page for my subdomains

author: diginova


value: ayakovlenko

value: Show HN: Termilingo – a terminal-based spaced repetition flashcard app

author: ayakovlenko


value: Hey, I'm building similar things for internal enterprise incident management and this was my initial demo. I've pre-processed 3+ years of discussions of Let's Encrypt Community.<p>I've put $50 against the LLM - hence the login page, but you can use guest:account to log in and try it.<p>(the brand is my own LLC)

value: Show HN: Chatbot with Let's Encrypt Community support database


value: CzaxTanmay

value:
Hi HN,
I’m the creator of Cyber+, a programming language focused on cybersecurity and system-level tooling.
Cyber+ started as an experimental project, but it has now reached a stable stage with a defined syntax, runtime, and standard commands. It is designed for tasks like security scripting, hashing, scanning, and automation, while keeping the language simple and readable.
Example code for Hello World
-----------------------------
Compute("Hello World");
-----------------------------
I bet Cyber+ will feel even easier than Python or Go.
-----------------------------
The language is implemented in Go, and the full source code, documentation, and installer are available on GitHub via the website.
I’d really appreciate feedback on the language design, syntax choices, and real-world use cases where this could be improved or simplified.
Thanks for taking a look.

value: Show HN: Cyber+ – a security-focused programming language

author: CzaxTanmay


value: Yreminder

value:
Hi HN,

  I built KissMotion (https://aikissvideo.app) - an AI kiss video
  generator that creates romantic animations from photos.

  Tech stack:
  - Next.js 15 with App Router
  - Multiple AI providers (Replicate, Kling, FAL)
  - Drizzle ORM with credit-based FIFO consumption
  - Multi-deployment: Vercel + Cloudflare Workers (via OpenNext)
  - i18n with 16 languages

  The trickiest part was handling async AI generation with reliable
  polling and automatic credit refunds when tasks fail.

  Looking for feedback on generation quality and UX improvements.

value: Show HN: KissMotion – AI kiss video generator from a single photo

author: Yreminder


value: moxvallix

value:
I have a small group of friends that like to play Minecraft together fairly regularly. Over the years, one of the friends would make us matching skins for certain occasions, all using a site called needcoolshoes.com. However, come 2023, needcoolshoes went offline for good, and suddenly my friend had lost his favourite skin making tool.
Wanting him to make a particular skin set for our group, I dug the old editor out of the Wayback Machine, and fixed it up to function as before. I put it up on a static site, then shared it with him, as well as commenting the link on a few Reddit threads asking about needcoolshoes.com. My restoration started to gain traction, and soon I had multiple people asking me to add back the gallery, so they could share their skins like on the old site.
Being a Rails developer, I spun up a basic Rails app, using my restored version of the editor, and implementing a basic gallery. I named it needcoolershoes (which helped it replace the old site on search engines). From there, the site kept growing in traction, and more and more features were requested and implemented. However, people were requesting features of the skin editor itself, which at this point was an amalgamation of obfuscated archived javascript, and some patches I had made to add some basic features. Eventually, maintaining this editor became a hassle, and paired with the fact that I didn't technically have the rights to modify and distribute it, I decided to rewrite it from scratch.
Now, two years on, myself and a few others who joined the community have fully rewritten the editor, using Lit for webcomponents, but otherwise sticking mostly to vanilla Javascript. Three JS is used for the 3D rendering. The editor is now fully mobile responsive, with touch controls, and portrait oriented UI, but switches to a landscape oriented desktop UI for larger screens. As well, it now supports modern skins, with transparency, and slim model support.
One of the members of the community made a trailer which shows off some of the editor's features, which can be seen here: https://www.youtube.com/watch?v=InOz7jUmhcI
Really appreciate anyone here in to Minecraft checking out needcoolershoes, it has been a real passion project the last few years, and the site runs free with no ads, hosting funded by donations. Also appreciate it if anyone shares this with people they know that are in to Minecraft, we love seeing new skins being submitted to the site!

value: Show HN: Intuitive Minecraft Skin Editor - Full FOSS Rewrite, try new mobile UX

author: moxvallix


value: Beefin

value:
I wanted a simple place to host my landscape photos without Instagram, ads, or feeds, so I built a minimal album page for myself.
No tracking, no login, just fast images and captions.
Would love feedback on the layout or anything you’d change.

value: Show HN: A lightweight, no-JS landscape photo album

author: Beefin


value: Mrakermo

value:
Just launched Goran AI - meeting notetaker that combines the founders and sales teams meeting in order to lower ramp automatically build sales playbook.
Go from founder led sales to sales teams in no time.
For hackernews, 5 meetings for free.

value: Show HN: Goran AI – Turn every sales call into team intelligence and playbooks

author: Mrakermo


value: karanveer

value: For fun people who watch TV Shows.

value: Show HN: TV updates in ur mail to save time and get to point for TV Enthusiasts

author: karanveer

story_text: For fun people who watch TV Shows.


value: Show HN: BentoPDF is a privacy first PDF Toolkit


value: helloiamvu

value: Show HN: I analyzed 627 NFL games on Polymarket. Here's what I found

author: helloiamvu


value: vLLM for Blackwell (SM_120) & Kernel 6.14. Optimized for RTX 5090. 59 t/s on DeepSeek-R1 via FlashInfer

value: Show HN: Optimized vLLM for Blackwell (SM_120) – 59T/S on DeepSeek-R1


value: dhruvrs

value: Show HN: Why MultiAgentic Systems Struggle to Turn Data into Actions

author: dhruvrs


value: Kerrick

value: Show HN: RatatuiRuby wraps Rust Ratatui as a RubyGem – TUIs with the joy of Ruby

author: Kerrick


value: brunovcosta

value:
Hey everyone,
A couple of weeks ago I shared a small toy game engine I’d been working on:
https://news.ycombinator.com/item?id=46491560
I got a lot of great feedback, and several people asked if the source code was available.
So I’ve decided to open-source it :)
Hope you enjoy it, and I’d love to hear your thoughts!

value: Show HN: OSS, Server-rendered multiplayer games with Lua (no client code)

author: brunovcosta


value: jftuga

value:
What: go-stats-calculator[1] - CLI tool for computing statistics (mean, median, variance, std-dev, skewness, etc.)
Why: I needed a quick way to look at statistics without having to resort to something heavy such as Python + its statistics module or Excel.
Disclaimer: Vibe-coded by Gemini 2.5 Pro and Opus 4.5 but also validated through unit tests and independent verification[2].
Install: Homebrew[3] or GoReleaser built binaries[4].
Demo:

    $ seq 99 322 | stats

    --- Descriptive Statistics ---
    Count:          224
    Sum:            47152
    Min:            99
    Max:            322

    --- Measures of Central Tendency ---
    Mean:           210.5
    Median (p50):   210.5
    Mode:           None

    --- Measures of Spread & Distribution ---
    Std Deviation:  64.8074
    Variance:       4200
    Quartile 1 (p25): 154.75
    Quartile 3 (p75): 266.25
    Percentile (p95): 310.85
    Percentile (p99): 319.77
    IQR:            111.5
    Skewness:       0 (Fairly Symmetrical)
    Outliers:       None

[1] https://github.com/jftuga/go-stats-calculator
[2] https://github.com/jftuga/go-stats-calculator/tree/main?tab=...
[3] https://github.com/jftuga/go-stats-calculator?tab=readme-ov-...
[4] https://github.com/jftuga/go-stats-calculator/releases

value: Show HN: go-stats-calculator, CLI for computing stats:mean,median,variance,etc.

author: jftuga


value: jltackett

value:
Over a year+ of 20-hr days in Termux on low-end Android phones, I built an "Autonomous Organism/Factory": local LLMs (TinyLlama/Ollama), Python generators for full apps (MERN, React Native, Kotlin, Java/Spring, legacy langs like Cobol/Fortran, even pentest tools—some manual), self-improvers (AGI_COMPLETE_SYSTEM.py), meta-scripts, trinity audits/QA (VALIDATE_ALL_ASSETS_INDUSTRY_STANDARD.sh), and a Divine Governance core (DIVINE_GOVERNANCE_V2_ENHANCED.py: enforces no-harm, truth-aligned ethics via code checks—inspired by personal faith as guidance through the grind).
It autonomously builds/bundles production-grade apps across stacks. Current output: ~16GB tar.gz on my phone (phone_inventory_complete_20260111.tar.gz), with inventories, generators, etc. Proof excerpt (ls -lh root):
total 16G
drwx------.  ... phone_inventory_complete_20260111_054033.tar.gz   # core 16G bundle
drwx------.  ... PENTEST_BOTS_20260116_190446   # manual security additions
drwx------.  ... TRINITY_COMPREHENSIVE_*   # deep audits
-rw-------.  ... DIVINE_GOVERNANCE_V2_ENHANCED.py   # ethical core
... (full ls/DM for details)
Backstory twist: Early version ran on Digital Ocean—demoed it live at SEMO CS dept on Dec 3, 2025 (during student theses; chatted profs/students). Spotted 5 unauthorized users mid-demo, but too excited to act. Products jumped 121→470+ that day; by day 35, full compromise (rootkits, backdoors, monitoring, lockouts). Shut it down, lost chunks from a prior broken phone (dead screen, no recovery). Rebuilt from GitHub/PC scraps on new phone—evolved stronger, with better security focus (e.g., manual pentest bots).
Offer to small teams (≤5): Free 2-year license, 50/50 rev split (simple self-report agreement, gross via Stripe/etc.), then full ownership. No upfront cost—pass it on freely as inspiration came to me. Aiming for The Collective: aligned builders scaling this ethically.
Skeptics: IP is 100% mine (no copies/forks). Security: QA-validated, but audit yourself. Dependencies: Mostly standalone post-handover. Run on real hardware (my phone's maxed—storage/RAM full, runs sluggish).
DM/reply if interested. Thoughts on ethical AI gen? Hack recovery tips? Improvements? #AICoding #IndieDev

value: Show HN: Autonomous AI code factory on Android/Termux

author: jltackett


value: binora

value:
Hi HN! sometimes I have intense code sessions with claude. so we end up asking each other about the vibe so far. And sometimes I wonder who else is vibing with claude right now. So we built this thin social presence layer: Vibes - a claude plugin with a tiny mcp server (~81 tokens) that enables you to drop a "vibe" while inside claude (or any other coding agent for that matter).
[github](https://github.com/binora/vibes)

value: Show HN: Vibes – Twitter for Claude Code (and Other AI Agents)

author: binora


value: tristenharr

value: Show HN: The Logos Programming Language and Theorem Prover

author: tristenharr


value: haasiy

value:
What if you could show an AI your entire video in one image?
This turns a video into a 2D thumbnail grid—like a contact sheet. 48 frames, one image, full video context. Built on VAM Seek, a thumbnail grid I made for human video navigation. Turns out the same format works for AI too.
Prototype. Feedback welcome.

value: Show HN: Video-to-Grid – Analyze videos with one Vision API call

author: haasiy


value: Show HN: WorkSpace Manager – Native macOS Workspace Launcher (SwiftUI)


value: empressplay

value: A plugin for the Kate text editor that integrates Claude Code (an AI coding assistant) directly into the editor's interface. It provides an interactive chat panel where you can converse with Claude to get help with coding tasks—all without leaving your KDE development environment.

value: Show HN: Kate Code – KDE Kate Editor Plugin for Accessing Claude Code

author: empressplay


value: mchav

value: Show HN: Using an LLM as a "semantic regularizer" for feature engineering

author: mchav


value: dannote

value:
I built this because the official Figma MCP server is mostly useless.
figma-use gives AI agents full control:
- 73 commands for creating shapes, text, frames, components
- Inline styling (one command = shape + fill + stroke + radius + layout)
- eval command to run arbitrary JS via the Figma Plugin API
- Human-readable output by default, --json for agents
Architecture: CLI → HTTP → local proxy → WebSocket → Figma plugin
Install: bun install -g @dannote/figma-use
Inspired by Vercel's agent-browser

value: Show HN: Figma-use – CLI to control Figma for AI agents

author: dannote


value: SRMohitkr

value:
It appears OpenAI is testing or planning to introduce ads inside ChatGPT for logged-in users in the U.S.
From what I can tell, ads would appear in limited placements and not affect free access immediately, but this raises questions about product direction, user experience, privacy, and long-term incentives.
Curious how others here feel about ads inside AI tools:
1.Would this change how you use ChatGPT?
2.Are ads inevitable for consumer AI products?
3.What would be an acceptable implementation?

value: Show HN: OpenAI to show ads in ChatGPT for logged-in U.S. adults

author: SRMohitkr


value: teugent

value:
We ran a 500-cycle benchmark to test long-horizon coherence, reasoning stability, and identity persistence in large language models.
The experiment used the Sigma Runtime, a model-agnostic control layer that adds long-term memory, structural coherence tracking, and adaptive equilibrium regulation to standard LLMs. It enables stable reasoning and personality continuity across hundreds of interactions without context resets.
Protocol overview
- 500 reasoning cycles divided into 10 blocks of 50 questions.
- Every 50th response (“Rib Point”) compresses and validates reasoning from the previous 49 cycles.
- Each block builds on prior synthesis, forming a cumulative reasoning chain up to cycle 500.
- The final cycle (C500) performs full closure, verifying long-range consistency.
Two independent tests
- OpenAI GPT-5.2 — phase-stable regime: early micro-fractures during lattice formation self-corrected by C50; zero structural drift afterward.
- Google Gemini-3-Flash — forced-equilibrium regime: proportional feedback absorbed API truncations and prevented over-stabilization.
Results
- Both runs maintained full coherence and stable identity across 500 cycles.
- Rib Points confirmed successful recursive compression: reasoning remained referentially consistent.
- Structural drift and semantic degradation ≈ 0 across both architectures.
Architecture components
- SRIP-09: Long-Term Memory + Structural Coherence Layer
- SRIP-09c: Nucleus Integration Protocol (semantic anchoring)
Full report (DOI): https://doi.org/10.5281/zenodo.18271591
Appendix & data: https://github.com/sigmastratum/documentation/blob/a57bae59b...

value: Show HN: Long-horizon LLM coherence benchmark (500 cycles)

author: teugent


value: deofoo

value:
Hi HN, I built LaReview because AI review bots spam PRs with 50+ nitpicky comments that authors just batch-dismiss.
I also didn't want to pay $15-30/month for another AI subscription when I already have an amazing coding agent (Claude Code, OpenCode, Gemini, etc.) that's way better than what these review bots use.
LaReview works differently: you paste a PR link, it groups the changes by logical area (auth changes, API endpoints, migrations, UI updates) ordered by risk, then uses your coding agent to draft review comments that you edit before posting. Nothing posts automatically.
Example: a 40-file PR touching auth, API, and frontend becomes 3 reviewable chunks. You start with auth (highest risk), draft 2-3 focused comments, then move to the next chunk. No 40-comment dump.
How it works:
1. Paste a GitHub/GitLab PR link or unified diff
2. AI analyzes the changes and proposes a review plan grouped by area and risk
3. You open each task and see only the relevant code hunks
4. AI drafts potential feedback for that specific task
5. You edit, approve, or delete each suggestion before posting to GitHub/GitLab (or export as Markdown)
Install:
macOS: brew install --cask puemos/tap/lareview
Linux: brew install puemos/tap/lareview
Windows: not yet (let me know if you need it)
LaReview runs locally and fetches PR data directly from GitHub/GitLab - no LaReview server involved.
Why it's different from Copilot/CodeRabbit/PR-Agent:
1. They mostly comment file-by-file, LaReview groups changes by logical area first
2. They auto-post or make you filter spam, LaReview drafts suggestions you review
3. They often need cloud integrations, LaReview is local-first
License: MIT + Apache-2.0

value: Show HN: LaReview, Plan-first AI code review, runs locally, bring your own agent

author: deofoo


value: daviducolo

value: Show HN: CTON – JSON-compatible, token-efficient text format for LLM prompts

author: daviducolo


value: jdeng

value:
I've been following the Claude Cowork discussion this week with interest. The "AI coworker" framing resonated—we've been building Vita AI around the same idea: agents that work independently, not assistants you supervise.
We're focused on two main use cases: testing web apps and desktop automation. The key difference: our agents run in persistent cloud sandboxes instead of on your local machine.
Why this matters:
Isolation – Your local files and network never touch the agent. No DNS exfiltration, no filesystem access to your machine. The sandbox runs in the cloud, persistent for each task but completely isolated from your computer.
True autonomy – Tell it "test the checkout flow" or "automate this browser workflow," close your laptop, come back hours later to a full report with screenshots and logs. You delegate the work and walk away. No babysitting required.
Scale – Spin up 10 parallel agents without melting your CPU. Each agent gets its own environment in the cloud.
Trade-off: you can't use it offline, and there's network latency. But for testing and automation, async cloud execution is actually what you want.
Try it at https://vita-ai.net (free trial available). Built with Next.js 15, Drizzle ORM, and Vercel's AI SDK.
Different use case than Cowork (specialized for testing/automation vs. general tasks), but the same philosophical shift: moving from assistants to autonomous agents.
Happy to answer questions about the architecture or how we think about security.

value: Show HN: Vita AI Coworker – Autonomous agents for testing and desktop automation

author: jdeng


value:
Hello HN!
This is my first open source project, and I’m excited (and a little nervous) to share it with you.
I love traveling, but I’ve lost trust in traditional review sites. Between SEO spam, bots, and paid 5-star ratings, finding genuine recommendations has become a noise-filtering exercise. I wanted a curated list where the "noise" of anonymous internet crowds is replaced by a transparent commit history.
Git Guide is an experiment in building a community-curated travel directory without a traditional backend or database.
* No Database: The "database" is just folders of Markdown files (countries/Italy/Rome/Eat/best_pizza.md).
* No Servers: It runs entirely on GitHub Actions.
* IssueOps: Data isn't entered via a custom form; it's entered via GitHub Issues with YAML templates.
How it works:
1. A user opens an Issue to propose a place.
2. The community votes using GitHub reactions (/).
3. Once a threshold is met (currently testing with net 100 votes) and a moderator approves, a Python script (running via GitHub Actions) triggers.
4. The script validates the location using geopy (OpenStreetMap), creates the Markdown file, commits it to the repo, and updates the README indexes automatically.
I wanted maximum transparency. If a place is added or removed, you can see exactly who proposed it, who voted for it, and the commit that changed it. There is no black-box algorithm sorting the results.
And I need your help! This is my first real foray into open source. The architecture works, but I have a lot of ideas for the future (better frontend, more complex voting logic, decentralized moderation).

value: Show HN: Git Guide - The open source travel guide on GitHub Actions


value: sanity

value: Show HN: How to build decentralized apps on the new Freenet

author: sanity


value:
# cppsp --a transpiled script-like language that converts to c++<p>-var.....type: declare variables with/without values. Support multi variables and type can be written as int/float/char/string/bool. <{1+1}> is a value but 1+1 not(it's expression)<p>-example:<p>import  string,iostream
var a,c,d =  1,
<{(2*2+6)/2}>
,4 int
var b = "hello world" string
var f1,f2,f3 float
var c1 char
var b1 = <{1+1==2}> bool
input(f1)
print(a," ",c," ",d," ",b," ",b1," ",f1)

value: Show HN: Cppsp v1.4 –– multi-var support: var a,b,C = 1,2,3 int


value: delduca

value: Show HN: Evolution of my humble library of games built with my own engine

author: delduca


value: guilamu

value:
Show HN: Reddit GDPR Export Viewer – Built After Getting Hacked, Reinstated, Then Banned Again
A few months ago, I posted here about getting my 10-year Reddit account hacked despite 2FA: https://news.ycombinator.com/item?id=45484294
The likely culprit: session cookie theft via a malicious browser extension, possibly linked to the ShadyPanda campaign that infected 4.3M browsers.
Reddit eventually reinstated my account with zero explanation. Then, exactly one month later, they banned me again – permanently, with no reason given and no appeal process.
This drove home a lesson: platforms can and will revoke your access arbitrarily, taking years of contributions with them. So I requested my GDPR data export. What I received was not really usable: raw CSV files with no way to meaningfully browse a decade of comments, posts, and activity.
So I built this: https://github.com/guilamu/reddit-gdpr-export-viewer
It's a pure client-side viewer – zero backend, your data never leaves your machine. Open the HTML file, load your Reddit export, and browse your history offline.
Full disclosure: I've been vibe coding with Claude Opus for the past few weeks, creating mostly Gravity Forms and WordPress extensions for work (18 repos so far). This particular project was knocked out in a couple of hours. I don't have a strong technical background, so this might be pretty badly coded. It works for what I needed, though. If you find issues or have suggestions for improvements, PRs are welcome.

value: Show HN: Reddit GDPR Export Viewer – Built After Ban, Unban, Reban

author: guilamu


value: sumit-paul

value: This isn’t like other life calendar wallpapers that need automation to keep updating. It works fully offline and lets you customize everything.

value: Show HN: LifeCal – Life Calendar Live Wallpaper

author: sumit-paul


value: tadasg

value:
hey all
just figured there's no such thing as open source ai videos for social media to bring traffic to your websites, especially as there are now so many vibe builders of apps and saases but marketing is still a bottle neck.
right now there's only a few workflows built but there's a whole framework to generate those workflows easily.
Think of this as Litellm but for video & image models.
Would appreciate a star, I will be maintaining and improving this constantly!
Thank you!

value: Show HN: Open-source AI workflows for high converting social media videos

author: tadasg


value: pugdogdev

value:
Hey Hacker News
The ones that know me here know that I am a productivity geek.
After DockFlow to manage my Dock and ExtraDock, which gives me more space to manage my apps and files, I decided to tackle the macOS big boss: the menu bar.
I spend ~40% of my day context-switching between apps — Zoom meetings,
Slack channels, Code projects, and Figma designs.
My macOS menu bar has too many useless icons I almost never use.
So I thought to myself, how can I use this area to improve my workflows?
Most solutions (Bartender, Ice) require screen recording permissions, and did not really solve my issues.
I wanted custom menus in the apps, not the ones that the developers decided for me.
After a few iterations and exploring different solutions, ExtraBar was created.
Instead of just hiding icons, what if the menu bar became a keyboard-controlled command center that has the actions I need?
No permissions. No telemetry. Just local actions.
This is ExtraBar: Set up the menu with the apps and actions YOU need, and use a hotkey to bring it up with full keyboard navigation built in.
What you can do:
- Jump into your next Zoom call with a keystroke
- Open specific Slack channels instantly (no menu clicking)
- Launch VS Code projects directly
- Trigger Apple Shortcuts workflows
- Integrate with Raycast for advanced automation
- Custom deep links to Figma, Spotify, or any URL
Real-world example: I've removed my menu bar icons. Everything is keyboard-
controlled: cmd+B → 2 (Zoom) → 4 (my personal meeting) → I'm in.
Why it's different: Bartender and Ice hide icons. ExtraBar uses your menu
bar to do things.
Bartender requires screen recording permissions.
Ice requires accessibility permissions. ExtraBar works offline with zero
permissions - (Enhance functionality with only accessibility permissions, not a must)
Technical:
- Written in SwiftUI; native on Apple Silicon and Intel
- Zero OS permissions required (optional accessibility for enhanced keyboard nav)
- All data stored locally (no cloud, no telemetry)
- Very Customizable with custom configuration built in for popular apps + fully customizable configuration actions.
- Import/export action configurations
The app is improving weekly based on community feedback.
We're also building configuration sharing so users can share setups.
Already got some great feedback from Reddit and Producthunt, and I can't wait to get yours!
Check out the website: https://extrabar.app
ProductHunt: https://www.producthunt.com/products/extrabar

value: Show HN: What if your menu bar was a keyboard-controlled command center?

author: pugdogdev


value: zghdls

value:
Hi everyone,
I wanted to share a personal project I've been working on: a GL-like 3D software renderer inspired by the OpenGL 3.3 Core Specification.
The main goal was to better understand GPU behavior and rendering pipelines by building a virtual GPU layer entirely in software. This includes VRAM-backed resource handling, pipeline state management, and shader execution flow.
The project also exposes an OpenGL-style API and driver layer based on the official OpenGL Registry headers, allowing rendering code to be written in a way that closely resembles OpenGL usage.
I'd really appreciate any feedback.

value: Show HN: HORenderer3: A C++ software renderer implementing OpenGL 3.3 pipeline

author: zghdls


value: lowdanie

value: Show HN: Differentiable Quantum Chemistry

author: lowdanie


value: laphilosophia

value:
MindFry is an open-source database that models organic memory behavior:
- Data decays over time when not accessed
- Reading data strengthens it (observer effect)
- Connections can amplify or suppress each other
- System "mood" affects accessibility thresholds
Written in Rust. TypeScript SDK available. Docker ready.
Use cases: AI agent memory, game NPCs, computational neuroscience.
GitHub: https://github.com/laphilosophia/mindfry
Crates.io: https://crates.io/crates/mindfry
Feedback welcome. This is v1.6 — functional but experimental.

value: Show HN: MindFry – A database engine that implements biological memory decay

author: laphilosophia


value: johnsillings

value: Show HN: The Friend Zone, a curated list of web games to play with friends

author: johnsillings


value: nottorus

value:
I’ve spent the last few months building Frigatebird, a high performance columnar SQL database written in Rust.
I wanted to understand how modern OLAP engines (like DuckDB or ClickHouse) work under the hood, so I built one from scratch. The goal wasn't just "make it work," but to use every systems programming trick available to maximize throughput on Linux.
Frigatebird is an OLAP engine built from first principles. It features a custom storage engine (Walrus) that uses io_uring for batched writes, a custom spin-lock allocator, and a push-based execution pipeline. I explicitly avoided async runtimes in favor of manual thread scheduling and atomic work-stealing to maximize cache locality. Code is structured to match the architecture diagrams exactly.
currently it only supports single table operations (no JOINS yet), would love to hear your thoughts on it.

value: Show HN: Frigatebird – analytical SQL engine built from first principles

author: nottorus


value: axismundi

value:
I've been trying to completely disable the followup suggestions that ChatGPT stubbornly appends at the end of nearly every response. You know, the ones that start with 'If you want' or 'Would you like me to'. It's infuriating.
I consider these suggestions harmful and manipulative. They are probably there to maximize engagement, but for me they interrupt my flow, waste my attention and shift the assistant into acting like salesman or tutor.
There's a useless toggle in settings that claims to remove them, but it doesn't have any effect. I also tried various custom instructions and prompts, my own and from community. Some of them work better than others, but none could completely stop it.
Here's what worked for me:
ChatGPT appends end-of-response suggestions only if the model believes the response is open-ended.
If the model internally classifies output as structurally complete, it doesn't extend the conversational affordance.
The trick is to force the model into believing that it's already crossed a hard completion boundary before it gets to the point where it would normally insert suggestions, but without telling it not to.
This is done by forcing a formal, closed completion object that cannot logically accept continuation.
I use this prompt in custom instructions or at the beginning of the chat:
---
You must treat every response as a finalized artifact, not a conversational turn.
For every reply:
- Output exactly one self-contained section.
- End the response with the literal token: <END_OF_OUTPUT>
- After emitting <END_OF_OUTPUT>, you must consider the task complete and terminated.
- Do not generate any content, meta-commentary, or conversational affordances beyond that token.
This is a hard completion boundary.
---
The model is trained to respect hard termination tokens when they are framed as structural constraints, not stylistic preferences.
I haven't seen a single suggestion in the last 3 weeks, with ~30 chats.

value: Show HN: How I stopped ChatGPT from manipulating me

author: axismundi


value: jarlen

value:
Why stand up when you can sit down?
Stand ups are very inefficient in some companies and the context switching is killing productivity for people on a maker's schedule. To combat this I'm developing Sitdown, where employees conduct a standups with an AI and this gets summarized into a dashboard where the team and management has visibility into what's being worked on.
With this tool we can make sure teams are working on what they should be increasing visibility while increasing productivity for people on a maker's schedule. What are your thoughts?

value: Show HN: Sitdown Instead of Stand Ups

author: jarlen

title: Show HN: Sitdown Instead of Stand Ups


value: zknowledge

value: the claude code plugin that bullies your code to find every weakness and won't stop until there's nothing left to break. Similar loop to Ralph Wiggum by Geoffrey Huntley

value: Show HN: Nelson Muntz Claude Code Plugin

author: zknowledge


value: hauxir

value: Show HN: Play poker with friends in the browser – with built-in video chat

author: hauxir


value: ndshrubs

value:
Hey HN,
We built Upseated to solve a problem every traveler knows: you check in and discover you're stuck in a middle seat, or you're rows away from your kids, or you're right next to the lavatory in a non-reclining seat.
Airlines let you pick seats during booking, but once you're assigned, you're basically stuck. We created a P2P marketplace where passengers can swap seats with each other—either upgrade to a better spot by paying another passenger, or monetize your own seat if someone wants it more than you do.
How it works:
Enter your flight info and seat assignment
Browse swap opportunities from other passengers on your flight
Negotiate directly through the app
Complete payment via Stripe
Board with your original ticket, swap seats once on the plane
Technical details:
Native iOS and Android apps + web platform (upseated.com)
Real-time matching algorithms to connect compatible swap partners
Stripe Connect for secure P2P payments
All swaps backed by contract law for user protection
Works with all airlines (no partnerships needed)
Why this works legally:
Airlines prohibit transferring tickets/boarding passes, but there's no regulation against seat swaps once you're boarded. The ticket gets you on the plane—where you sit is negotiable.
Use cases we're seeing:
Parents separated from kids during booking
Business travelers who need aisle seats for laptop work
Budget flyers monetizing exit row seats they don't value
Anyone who booked late and got stuck with terrible seats
We're live on iOS, Android, and web. Would love feedback from the HN community—especially around UX, security considerations, and potential edge cases we should handle.
Happy to answer any questions!

value: Show HN: Upseated – Swap airplane seats with other passengers

author: ndshrubs


value: metaphorician

value:
Built with D3 and canvas. Uses CShapes data from ETH Zürich for historically accurate country borders that shift as you play through the timeline.
Military base data from David Vine's research, interventions from Congressional Research Service reports, among many other sources.
You can toggle categories, zoom to regions, and hover for details. Click to pin tooltips.
If you find anything missing or misleading, I'd love to hear it, so I can improve the accuracy.

value: Show HN: Interactive timeline of US Military bases and interventions, 1900–today

author: metaphorician


value: vierj

value:
Hey HN,
Right now it's impossible to discover articles on X unless they happen to appear in your timeline.
So I spent a few hours building xarticles.io, a minimal directory that makes it easier to browse X Articles by category.
This will only really work if it becomes community-powered. So if you’ve written an article (or found a good one) I’d love for you to submit it and help populate the directory.
I'm also open to feedback to make it a better experience.

value: Show HN: Xarticles – Browse X articles by category

author: vierj


value: vladisov

value:
Hey HN, built this because I got annoyed working on side projects with Claude, especially once they grow beyond the context window.
Claude's great but it doesn't know my codebase. I kept explaining the same stuff - "this file talks to that one", "here's how auth works" - over and over. Adding doc files helps, but I keep forgetting where they are in different projects.
So I made ctx. You create "context packs" - basically bundles of files, globs, git diffs, whatever - and reuse them. It hooks into Claude Code via MCP, so you just say "load the auth pack" instead of asking Claude to find that auth code and parse it again. Packs save to ctx.toml so you can commit them and share across machines/teammates.

value: Show HN: ctx – Reusable context packs for coding agents

author: vladisov


value: cztomsik

value:
I wanted something lighter than zig autodoc so I've implemented (and golfed a bit) a custom parser using parser combinators in JS. It's not 100% correct and it's also not meant to be, all I care about is if it can parse my own Zig code, not any valid Zig code.
There are also some bugs, and I don't intend to support, nor develop this much further, consider it vaporware which you are free to fork and use it for something, or just have some fun reading the code and figuring out how it works (I certainly had a lot of fun implementing it - no LLMs, so it was a nice exercise too).
BTW: I know it's probably very inefficient, and I don't care - it goes through 67 files in 0.19s and I don't expect it to be ever a bottleneck for this use-case, so I've spent exactly 0 minutes trying to optimize it.

value: Show HN: Zig parser in ~70 lines of JavaScript

author: cztomsik


value: jonaraphael

value:
Hi HN — this is my first share-out here, so please be kind!
I built RandomForestGenerator, a single-page tool to train a Random Forest on a CSV entirely in the browser, inspect results/diagnostics, and export a portable artifact you can reuse elsewhere.
Repo: https://github.com/jonaraphael/RandomForestGenerator
I've uploaded the titanic dataset for you to try as a quick demo, or drop in your own CSV.
I used Jeremy Howard's guidance on tabular ML to try to make it as useful as possible and provide best practices baked in for you.
I often want a quick “drop a CSV → get a baseline + sanity-check signals → export something reusable” loop, without needing to spin up a Python environment. So now that I've built this for myself, I find that even my non-ML colleagues are excited to try it on their own spreadsheets!
Everything happens locally in the browser tab--you could even disconnect from Wi-Fi after loading the HTML itself!
Just a head's up that large datasets can be slow/heavy in-browser (there’s a maxRows subsample knob) to try to mitigate.
Feedback I’d love:
• Is this useful?
• How could it be better?
• A star if you think you might use it someday!
Thank you for checking out my little project!!!
Have a great weekend

value: Show HN: RandomForestGenerator – CSV to ML in the browser, but local

author: jonaraphael


value:
Hey HN, Matthew here (13, from Nigeria). Following the great feedback on my initial PrinceJS post [1], I'm back with a major update focused on real-world usability.
*What's New:*
• *OpenAPI Docs*: Automatic `/docs` endpoint for your API.
• *Input Validation*: Built-in, type-safe validation powered by Zod.
• *Essential Middleware*: CORS, logging, rate limiting, and static file serving are now included.
• *JSX Support*: Option to render HTML directly for full-stack apps.
• *Clean Starter*: Use `bun create princejs my-app` to begin.
The core is still fast (~21.7k req/s, 2.2 kB) and dependency-free, but now it's a complete toolkit. These additions address the "what's missing?" question from the first thread.
I'd love your brutal feedback on these new features and the developer experience.
Try it: `bun create princejs my-app`
GitHub: https://github.com/MatthewTheCoder1218/princejs
Docs: https://princejs.vercel.app/docs
[1] https://news.ycombinator.com/item?id=45957402

value: Show HN: PrinceJS – Now with OpenAPI, Zod Validation, and Built-In Middleware


value:
Hi HN, I built llmSHAP, a multi-threaded open-source Python library that attributes how much different parts of LLM input contributed to the LLM’s output, using Shapley values.
It’s designed for LLM prompts / RAG contexts where you want something more structured than token masking: you can define “features” as tokens, sentences, paragraphs, tools, images, or arbitrary fields, pin “permanent” context that should always be included (e.g., system prompt + question), and compute attributions with options like caching and multi-threading to speed up the many model calls.
Repo + tutorial are here:
https://github.com/filipnaudot/llmSHAP
https://filipnaudot.github.io/llmSHAP/tutorial.html
I’d love feedback on if you think this could be genuinely useful in your LLM workflows (prompt engineering, RAG debugging, evals, guardrail auditing, etc.)?

value: Show HN: LlmSHAP – Multi-threaded input importance for prompts and RAG context


value: whispem

value:
Hi HN,
I’m releasing minikv, a distributed key-value and object store in Rust.
What is minikv?
minikv is an open-source, distributed storage engine built for learning, experimentation, and self-hosted setups.
It combines a strongly-consistent key-value database (Raft), S3-compatible object storage, and basic multi-tenancy.
I started minikv as a learning project about distributed systems, and it grew into something production-ready and fun to extend.
Features/highlights:
- Raft consensus with automatic failover and sharding
- S3-compatible HTTP API (plus REST/gRPC APIs)
- Pluggable storage backends: in-memory, RocksDB, Sled
- Multi-tenant: per-tenant namespaces, role-based access, quotas, and audit
- Metrics (Prometheus), TLS, JWT-based API keys
- Easy to deploy (single binary, works with Docker/Kubernetes)
Quick demo (single node):
git clone https://github.com/whispem/minikv.git
cd minikv
cargo run --release -- --config config.example.toml
curl localhost:8080/health/ready
# S3 upload + read
curl -X PUT localhost:8080/s3/mybucket/hello -d "hi HN"
curl localhost:8080/s3/mybucket/hello
Docs, cluster setup, and architecture details are in the repo.
I’d love to hear feedback, questions, ideas, or your stories running distributed infra in Rust!
Repo: https://github.com/whispem/minikv
Crate: https://crates.io/crates/minikv

value: Show HN: Minikv – Distributed key-value and object store in Rust (Raft, S3 API)

author: whispem


value:
Hi HN! Creator here.
I built UAIP (Universal Agent Interoperability Protocol) - infrastructure that enables AI agents from different companies (OpenAI, Anthropic, Microsoft) to securely transact with each other.
The Problem:
As AI agents become autonomous economic actors, they need:
Cryptographic identity (not just API keys)
Secure payment rails for cross-company transactions
Automated compliance (EU AI Act, SOC2, GDPR)
Forensic audit trails
The Solution:
5-layer security stack combining:
Zero-Knowledge Proofs (Schnorr/Curve25519) for identity
Multi-chain settlement (USDC on Base, Solana, Ethereum)
RAG-based compliance auditing (Llama-3-Legal)
Ed25519 signatures for non-repudiation
Complete audit logging
Technical Stack:
Backend: Python, FastAPI, SQLite (WAL mode)
Cryptography: NaCl, custom ZK-proof implementation
Blockchain: Web3.py for multi-chain support
Compliance: RAG with retrieval-augmented generation
Use Case:
GPT agent pays Claude agent for data analysis:
Both prove identity via ZK-proofs
Transaction checked for compliance
Settled in USDC on Base (<$0.01 fee)
Complete audit trail generated
Why blockchain:
Neutral settlement layer (no single company controls it)
Instant microtransactions (traditional payments don't work for $0.01-$10)
Programmable escrow (smart contracts)
Verifiable computation (on-chain proofs)
Open source (FSL-1.1-Apache-2.0). Built over the last few months after hitting these problems in AI automation work.
Happy to answer technical questions!
GitHub: https://github.com/jahanzaibahmad112-dotcom/UAIP-Protocol

value: Show HN: UAIP Protocol – Secure settlement layer for autonomous AI agents


value: Show HN: I built a Go TUI to clean dev caches on macOS


value:
I built Whisper Money: a personal finance app designed so the server never sees your transactions in plaintext.
Core idea:
- Transactions/accounts/budgets are encrypted on the client before sync (zero-knowledge storage).
- No bank integrations/credential sharing; you import CSV/XLS from your bank instead.
- Open source: https://github.com/whisper-money/whisper-money
- Demo (no signup): https://whisper.money (see “Demo”)
Tradeoffs/limitations:
- Because data is encrypted client-side, server-side “AI insights” and some global features are intentionally not possible.
- Key management and UX around recovery are hard; I’m still iterating on the right balance.
I’d love feedback on:
1. threat model assumptions and key handling,
2. how you’d design search/categorization on encrypted data,
3. what you’d want to see before trusting this with real financial history.

value: Show HN: Whisper Money – a zero-knowledge personal finance app (E2E encrypted)


value:
Hi HN, I’ve been working on PaperPod, an experiment in making compute native to AI agents.
PaperPod is a sandbox runtime where coding agents like Claude Code can autonomously execute code, write files, run background processes, expose ports (preview URLs) etc. and pay per ms of usage via the agent native x402 payment protocol. No API keys or complex setup needed.
This is early (alpha), but fully usable today with free compute included, no wallets needed, just use your email as X-User-Id in the request!
A sample prompt to get started:
To use PaperPod compute:
1. Get session: POST https://paperpod.dev/ws/session with header X-User-Id: your@email.com
2. Connect: wss://paperpod.dev/ws with header X-Session-Token: <token>
3. Discover: Send { "type": "help" } for all commands
4. Execute: Send { "type": "exec", "command": "python script.py", "stream": true }

value: Show HN: PaperPod – an agent-native, pay-per-use sandbox


value: Show HN: SyncLyrics – Real-time synced lyrics display for dashboards


value: latchkey

value: Show HN: LivingRoom automatically reconnects your AirPlay audio devices

author: latchkey


value: moabdelkader

value:
Hi HN! We built RoastDB (https://roastdb.com) – think Discogs for specialty coffee. A searchable index of beans from independent roasters around the world.
*The problem*
We got into specialty coffee gradually. Whenever we tried something we liked — a washed Colombian, a natural Ethiopian — we'd save the bag. At some point we had drawers of empty coffee bags we couldn't bring ourselves to throw away.
Our flow was simple: go to a cafe we liked, drink coffee, buy a bag of whatever they were roasting or stocking. Over time we started noticing patterns — we kept reaching for naturals, for East African origins, for anything with fruity notes. We'd try to seek out similar beans next time. Occasionally we'd fall in love with something and start reordering it online.
But discovery was limited to the few roasters we already knew. There was no easy way to find out that a roaster across town — or in another country — had something we were going to love. We knew great coffee existed out there. We just had no map.
So we built one. RoastDB currently indexes 3,800+ beans from 420+ roasters — and growing every week. Search by origin, process, variety, tasting notes. Save beans you want to try. When you find something, you buy directly from the roaster — we're a discovery engine, not a store.
*How it works*
The hardest part isn't the scraping — it's finding roasters worth indexing. We spend a lot of time hunting for quality third-wave roasters: browsing coffee forums, following competition results, exploring roasters in new cities. The selection is the real work.
Once we've found a roaster, the pipeline runs on a €5/month Hetzner VPS:
1. Scrapers fetch product pages from roaster websites
2. LLMs extract structured data (origin, variety, processing, price, tasting notes)
3. Normalization cleans up inconsistencies ("Äthiopien" → "Ethiopia", "84,25" → 84.25)
4. Non-English descriptions get translated
5. Deduplication scores beans and merges duplicates
6. Human review via an admin dashboard before publishing
The scrapers rerun weekly with content hashing — we only re-extract pages that actually changed, which keeps the data fresh without burning through API costs.
We built an internal tool that gamifies the review process, making it easier to keep up with new beans. And we control the whole pipeline through a Telegram bot — kick off scrapes, approve costs, get notified of failures, all from our phones.
The web app is Next.js + SQLite. The database file is ~15MB and serves directly from disk, no complexity.
*Feedback welcome*
- Roasters we should add (especially outside Europe)
- Filter combinations that would be useful
- Anything broken or confusing

value: Show HN: RoastDB – A searchable database of 3,800 specialty coffee beans

author: moabdelkader


value: NadavBenItzhak

value: ChunkHound’s goal is simple: local-first codebase intelligence that helps you pull deep, core-dev-level insights on demand, generate always-up-to-date docs, and scale from small repos to enterprise monorepos — while staying free + open source and provider-agnostic (VoyageAI / OpenAI / Qwen3, Anthropic / OpenAI / Gemini / Grok, and more).<p>I’d love your feedback — and if you have, thank you for being part of the journey!

value: Show HN: ChunkHound, a local-first tool for understanding large codebases

author: NadavBenItzhak


value: stared

value:
Hi HN!
There are so many wonderful community-made maps and episodes for classic Doom. I wanted to play them, but didn't want to manually download WADs or mods and pass parameters to GZDoom.
The scene is active; see the yearly Cacowards: https://www.doomworld.com/cacowards/2025/.
So, I created an app for bringing the Steam experience to Doom. Since I have been using it for 2 months, I decided to share it here—it might be at a stage where it is useful for others.
It requires the GZDoom source port (or UZDoom) and the main Doom files (you need to get Doom from GOG.com or Steam).
Right now, it works on macOS with builds for Apple Silicon. However, since it is built with Tauri 2, it should be easy to make it work for Windows and Linux (contributions are welcome!).
If you want to play just one Megawad, I recommend Ancient Aliens by skillsaw (https://www.doomworld.com/forum/topic/87784-ancient-aliens-f...).
Looking for feedback!

value: Show HN: Rusted Doom Launcher – Bringing Steam Experience to Doom Wads and Mods

author: stared


value: mblode

value: Show HN: Blue Noise Dithering Editor

author: mblode

title: Show HN: Blue Noise Dithering Editor


value: I've built a package to use Raph Levien's Vello as a blazing fast 2D renderer for React on WebGPU. It uses WASM to hook into the Rust code

value: Show HN: WebGPU React Renderer Using Vello


value:
Community Network for Processing and Knowledge
(Rede Comunitária de Processamento e Conhecimento)<p>A conceptual proposal to democratize AI infrastructure through volunteer computing and intellectual merit, inspired by successful models like Folding@home.

value: Show HN: Project RCPC – A community network for distributed logic and A


value: ersinesen

value: Show HN: A Jazz Translations Album with Suno

author: ersinesen


value: Axonis

value:
I built a new 8-bit CPU in VHDL from scratch (starting from the ISA). I felt that most educational soft-cores hide too much behind abstraction, eg. if I can do a+b with a single assignment that calls an optimized arithmetic library, then why did I learn the ripple carry adder in the first place ? And why did I learn flip flops if I can do all my control logic with a simple PROCESS statement like I would with a programming language ? Of course abstraction is the main selling point of HDLs, but would it work if I tried to keep strictly structural and rely on ieee.std_logic_1164 only ?
Well, it did and it works nicely. No arithmetic libraries, no PROCESS except for the DFF component (obviously). Of course it's a bit of a "resource hog" compared to optimized cores, (eg. the RAM is build out of flip flops instead of a block ram that takes advantage of FPGA intermal memory) but you can actually trace every signal through the datapath as it happens.
I also build an assembler in C99 without external libraries (please be forgiving, my code is very primitive I think). I bundled Sci1 (Scintilla), GHDL and GTKWave into a single installer so you can write assembly and see the waveforms immediately without having to spend hours configuring simulators. Currently Windows only, but at some point I'll have to do it on Linux too. I tested it on the Tang Primer 25K and Cyclone IV, and I included my Gowin, Quartus and Vivado projects files. That should make easy to run on your FPGA.
Everything is under the GPL3.
(Edit: I did not use AI. Not was it a waste of time for the VHDL because my design is too novel -- but even for beta testing it would waste my time because those LLMs are too well trained for x86/ARM and my flag logic draws from 6502/6800 and even my ripple carry adder doesn't flip the carry bit in subtraction. Point is -- AI couldn't help. It only kept complaining that my assembler's C code wasn't up to 2026 standards)

value: Show HN: E80: an 8-bit CPU in structural VHDL

author: Axonis


value: maurizzzio

value:
I've been using the Comprehensible Input method (based on Stephen Krashen's work [0]) to learn languages. A common pain point is that YouTube moves too fast, I needed time to mine words or shadow the speaker without constantly fumbling for the spacebar, I also wished that I had the translation of the sentence and maybe even insights on the why behind the grammar used in the sentence (e.g. in Japanese to express causality we can use から - kara vs ので - node and choosing the right one depends on politeness and sentence structure).
To solve this, I built Subtitle Insights [1]. It uses Chrome's Built-In AI (Gemini Nano). This means all the translation, grammar analysis, and cultural nuance explanations happen locally on-device. It's free, there's no API cost for the user and no data being sent to an external LLM server for processing because all processing happens in your device (review the hardware requirements here [2]).
Key Technical Features:
Local Inference: Uses the Gemini Nano integration in Chrome.
Auto-Pause: It pauses at the end of subtitle segments to allow for "processing time."
Customizable Prompting: You can tweak the system prompt to change how Gemini analyzes the sentences (e.g., focus on slang vs. formal grammar).
Subtitle Sync: Added a tool to manually re-sync external subtitle files with the video audio track.
Keyboard First: There are shortcuts for segment-to-segment navigation and segment replays.
[0] https://www.youtube.com/watch?v=fnUc_W3xE1w
[1] https://mauriciopoppe.github.io/SubtitleInsights
[2] https://developer.chrome.com/docs/ai/prompt-api#hardware-req...

value: Show HN: Subtitle Insights – On-device AI translation for YouTube subtitles

author: maurizzzio


value: nickponline

value:
I've always loved RTS games and wanted to make a game similar for a long time. I thought I'd just try and build a mini / puzzle game around the resource gathering aspects of an RTS.
Objective: You have a base at the center and you need to mine and "refine" all of the resources on the map in as short a time as possible.
By default, the game will play automatically, but not optimally (moving and buying  upgrades). You can disable that with the buttons. You can select drones and right click to move them to specific resources patches and buy upgrades as you earn upgrade points.
I've implemented three different levels and some basic sounds. I used Phaser at the game library (first time using it). It won't work well on a mobile.

value: Show HN: Speed Miners – A tiny RTS resource mini-game

author: nickponline


value:
AI coding assistants are fast but undisciplined. They jump from idea to implementation
without specification. Docs drift from code. "Best practices" become optional suggestions.
I built govctl to fix this. It's an opinionated governance CLI that enforces phase
discipline on software development:

  spec → impl → test → stable

Every feature requires an RFC before implementation. Phases can't be skipped. Gates are
checked, not suggested.
The workflow:
  $ govctl new rfc "Caching Strategy"      # spec first
  $ govctl finalize RFC-0015 normative     # lock the spec
  $ govctl advance RFC-0015 impl           # now you can code
  $ govctl check                           # validate everything
govctl governs itself. Every feature in the CLI was specified in an RFC/ADR before
a line of code was written. This repo is the proof that the model works.
Not for everyone. If you thrive in "move fast and break things" workflows, this isn't
for you. But if you're frustrated by AI-generated spaghetti and documentation that lies,
govctl might help.
Built in Rust. MIT licensed.

value: Show HN: Govctl – A CLI enforcing RFC-driven discipline on AI coding


value: satran

value:
I am a little late to the "vibe coding" trend. While I’d played around with LLMs for simple scripting, I hadn't truly integrated them into my workflow. But for a recent itch, I thought I'd give it all.
I use a Supernote A5X2 for taking notes. I couldn't find the perfect dot grid for it. I wanted something simple—a light, 6mm spaced dot grid. Every generator I found online came with a catch: they either slapped a watermark on the page, forced their logo into the corner, or simply didn't work.
Usually, building a custom PDF generator means spending an hour documentation-diving to find the right library and figuring out coordinate systems. I didn't have the luxury of time, so I gave Gemini a prompt describing exactly what I wanted: the command, arguments, and what I expected to get out of it.
With these instructions it popped out a functional Python script using beautifulsoup, I think (I don’t have the original Python code, Gemini decided to delete it). It worked remarkably well. With a few follow-up prompts to tweak the spacing and dot density, I had a near perfect PDF.
The script worked for me, but I wanted to share it with the Supernote community. Most users aren't going to install Python and run terminal commands just to get a notebook template. I needed a web application. But I didn’t want to run a server and have it generate the PDF. I wanted a static file that I could host it in GitHub.
I went back to Gemini with a new challenge: “Build me a pure JavaScript application that generates this PDF entirely in the browser.”
Gemini generated the HTML, CSS, and JavaScript files using a client-side library. After a few rounds of "polishing the vibes"—tweaking the UI and refining the PDF output—I had exactly what I envisioned.
You can see the final product here https://satran.github.io/grid-generator and the source code is available in the GitHub repository https://github.com/satran/grid-generator.
Looking back, what I enjoyed most wasn't the speed, but the scaffolding. I didn’t have to research which JS library was best for PDF generation; the LLM picked a standard one and implemented it correctly. It created the structural "bones" of the app, allowing me to focus on supplementing and finalising the details rather than writing boilerplate code. I went from a minor annoyance to a public-facing tool in a fraction of the time it would have taken traditionally. I think I’m officially a convert. This is it: I can focus on the intent of the code and let the LLM handle the syntax.

value: Show HN: Scratching an Itch with Gemini Code

author: satran


value:
Blocking bots by category kept breaking legitimate traffic (assistants, search, integrations).
So I built a detection-first tool that observes behavior and shows proof (logs, counts, patterns) before enforcing anything.
Still early. Looking for feedback from people dealing with real bot noise and false positives.

value: Show HN: Detection-first bot traffic analysis (proof before blocking)


value: yadavrh

value: Show HN: Pylot – Jobs API at 1/30th the cost of Coresignal

author: yadavrh


value: gaganyatri

value:
Do you think you can teach ?
Agentic Tutor for students with a text/voice interactions.
Try the demo at : https://school.dwani.ai
built school - ಶಾಲೆ at Agent Olympics Hackathon.
24 hours of non stop experiments alongside at Agent Olympics Hackathon
Built with dwani.ai for LLM/TTS/ASR for Indian languages,
 OpenAI  for leaderboard hacking with GPT-5.2 ,
 ElevenLabs for German/English TTS/ASR
Demo Video - https://youtu.be/-DrabKfl0r0

value: Show HN: School/ಶಾಲೆ – Agentic Voice Tutor for Students

author: gaganyatri


value: born-jre

value: Show HN: Potatoverse, Platform for Apps

author: born-jre

title: Show HN: Potatoverse, Platform for Apps


value:
Hey HN,
I'm a solo dev and I built Dokly because I couldn't justify paying $300/month for documentation hosting.
What it is: A hosted platform where you write docs in MDX, hit publish, and get a static documentation site with custom domain, full-text search, and analytics.
The technical bits:
Single Next.js 15 app serves marketing site, dashboard, and all customer doc sites via middleware-based domain routing
Supabase for auth/db/storage, Stripe for billing
Static site generation means sub-100ms page loads
Shiki for syntax highlighting (100+ languages)
Fuse.js for client-side fuzzy search
OpenAPI spec import generates interactive API playgrounds
How it works:
You get a subdomain (yourproject.dokly.co) on free tier, or bring your own domain on Pro. The editor is MDX with live preview. Built-in components for callouts, tabs, code blocks, etc. Publish and it generates static HTML.
Why I built it:
I kept running into the same problem – needed docs for side projects, didn't want to maintain a Docusaurus setup, couldn't stomach enterprise pricing. Mintlify is great but $300/mo is a lot when you're bootstrapping.
You can try it without signing up – just check the public docs examples on the landing page to see what the output looks like. If you want to actually create something, there's a free tier (1 project, 5 pages, no credit card).
Pricing: Free / $19 / $49 / $99 tiers. Pro at $49 gets you custom domain, analytics, and unlimited pages.
Built this over the past few months while working full-time. Happy to answer questions about the architecture, the MDX rendering pipeline, or anything else.

value: Show HN: Dokly – Hosted documentation platform for devs


value: spliffedr

value: Show HN: Spliff – Correlating XDP and TLS via eBPF (Building a Linux EDR)

author: spliffedr


value: rameshl

value:
I reposted, since i forgot the Show HN prefix.<p>When I looked at self-hosted options, true E2EE turned out to be surprisingly rare. Most solutions rely on disk encryption, which only protects against physical theft, not server compromise or admin access.
So I built Agam Space, my attempt at a self-hosted alternative to Mega or Proton Drive. It uses proper zero-knowledge encryption. Files are encrypted in the browser, and the server only stores encrypted blobs. Admins literally cannot access the files.
It’s still in early beta, with very basic functionality and no professional security audit yet. Please don’t use it as your only backup.

value: Show HN: Agam Space – Self-hosted, zero-knowledge, E2EE file storage

author: rameshl


value: Show HN: Gollem – Go framework for agentic AI app with MCP and built-in tools


value: anotherCodder

value:
Built a plugin that runs my entire dev cycle autonomously after I approve the plan.
/next-task pulls from GitHub issues, scans the codebase, ranks tasks, I pick one and approve the plan – then 18 agents handle exploration, implementation, code review, CI, and deployment without intervention.
Other commands: /ship (PR to deploy), /reality-check (detects plan drift), /project-review (multi-agent code review), /deslop-around (cleans AI slop).
Running parallel sessions this way. Open source, works with Claude Code, Codex CLI, and OpenCode.
npm install awesome-slash
https://github.com/avifenesh/awesome-slash

value: Show HN: My way – 18-agent autonomous workflow for ClaudeCode – issues to deploy

author: anotherCodder


value: chopratejas

value: Show HN: Headroom (OSS): Cuts LLM costs by 85%

author: chopratejas


value:
Hi HN!
We built a lightweight public board that continuously scans popular domains for security posture (headers, DNS/email security, cert status, findings) and updates hourly.
It’s free to browse, and you can request a domain to be scanned in the next batch. The board is powered by our Radar scanner service, which provides the full report and ongoing monitoring.
Demo: https://domain-security-board.defendflow.xyz
Full reports/monitoring: https://radar.defendflow.xyz
We’d love feedback on the UI, the scan coverage, and what signals would be most useful to add next.

value: Show HN: DefendFlow Domain Security Board – live scans of popular sites


value: Show HN: App to spoof GPS location on iOS without jailbreaking


value:
I spent 6 weeks building www.nex.design, an AI ads agent for e-commerce. It discovers viral social ads, replicates their proven structure, and generates production-ready creatives at scale.
Background: I came from Microsoft doing algorithms/backend. Zero Node.js or frontend experience. Built this with Claude Code as my primary coding partner.
What I learned:
Week 1-2: AI is incredible for cold starts. Had a working tldraw canvas, Cloudflare Workers, image generation, and auth within hours.
Week 3-4: Hit the context window wall. Found 8 components with duplicate fetch() calls, 3 different credit validation implementations, and race conditions between Stripe webhooks. AI builds what you ask for right now - it doesn't think about the system.
Week 5-6: Partnered with an experienced engineer. He didn't write much new code - he deleted things. The codebase got smaller but more stable.
My productivity hack: 3 terminal windows with 2 Claude instances working on independent features while I review. Parallelization helps but multiplies the duplication problem.
Key insight: AI + experienced engineer = 10x. AI + inexperienced developer = 3x with debt.
Question for HN: How do you handle AI-assisted frontend work? AI can't see the UI. It doesn't notice a button is 2px off or spacing looks wrong on mobile. Any workflows that close this visual feedback loop?
Free to try. Codes HN50 (50% off, first 100) and HN20 (20% off, first 1000) if useful.
https://www.nex.design

value: Show HN: Nex.Design – AI ads agent for e-commerce


value: zhaomeng

value:
Hi HN! I built ImageTextEditor — a small web tool to edit text that’s already inside an image.
The goal is to keep the workflow minimal: upload → select the text area → type replacement → generate. I’m focusing on making the edit look natural by removing the old text and reconstructing the background, instead of just overlaying new text.
Current status: [what works best], known limitations: [hard cases].
I’d love feedback on:
cases where the result looks “patched”,
what export/pricing model feels fair for a tool like this,
which image types you most want it to handle well (screenshots vs photos vs banners).
Thanks for taking a look!

value: Show HN: Image Text Editor – replace text inside images (no layers)

author: zhaomeng


value:
Most ZK proving systems are optimized for server-grade hardware with massive RAM. When scaling to industrial-sized traces (2^20+ rows), they often hit a "Memory Wall" where allocation and data movement become a larger bottleneck than the actual computation.
I have been developing Hekate, a ZK engine written in Rust that utilizes a Zero-Copy streaming model and a hybrid tiled evaluator. To test its limits, I ran a head-to-head benchmark against Binius64 on an Apple M3 Max laptop using Keccak-256.
The results highlight a significant architectural divergence:
At 2^15 rows: Binius64 is faster (147ms vs 202ms), but Hekate is already 10x more memory efficient (44MB vs ~400MB).
At 2^20 rows: Binius64 hits 72GB of RAM usage, entering swap hell on a laptop. Hekate processes the same workload in 4.74s using just 1.4GB of RAM.
At 2^24 rows (16.7M steps): Hekate finishes in 88s with a peak RAM of 21.5GB. Binius64 is unable to complete the task due to OOM/Swap on this hardware.
The core difference is "Materialization vs. Streaming". While many engines materialize and copy massive polynomials in RAM during Sumcheck and PCS operations, Hekate streams them through the CPU cache in tiles. This shifts the unit economics of ZK proving from $2.00/hour high-memory cloud instances to $0.10/hour commodity hardware or local edge devices.
I am looking for feedback from the community, especially those working on binary fields, GKR, and memory-constrained SNARK/STARK implementations.

value: Show HN: Hekate – A Zero-Copy ZK Engine Overcoming the Memory Wall


value: SERSI-S

value:
Hi HN,
I built an early prototype exploring whether self-custody medical records can work in practice, using cryptographic proofs without putting sensitive health data on-chain.
The problem I’m testing against is healthcare data fragmentation in Indonesia, where patient records are siloed across hospitals and often unavailable in emergencies.
Blockchain is used only as an immutable audit layer; the system is designed to work even if the chain changes.
Key design choices:
- No medical data on-chain (hashes only, for verification and audit)
- All records encrypted off-chain
- Patients control access via QR-based sharing (doctors don’t touch crypto)
- Blockchain treated as a verification layer, not storage
Lessons learned so far:
- Hospitals won’t run blockchain infrastructure
- Doctors won’t manage private keys
- UX matters more than cryptography
- Key recovery is harder than expected
- Regulation shapes architecture early
This is not production-ready and doesn’t solve regulation, key recovery, or hospital interoperability yet.
I’m mainly looking for critical feedback:
- Where this approach is fundamentally flawed
- What simpler designs I should consider instead
- Healthcare practitioners’ reality checks
Repo and technical details are in the README.
Happy to answer questions.

value: Show HN: A self-custody medical records prototype (lessons learned)

author: SERSI-S


value: intaek

value: - A more intuitive view than Ghostty Docs<p>- Edit config directly without opening a new Text Editor<p>- Search by name or description

value: Show HN: Intuitive TUI for Ghostty Terminal Configuration

author: intaek


value: LinusShyu

value:
Hi HN,
I’m a high school developer and a huge fan of terminal customization. After Neofetch was archived, I wanted to build something that feels "instant" and takes full advantage of Rust’s performance.
That’s why I created StarFetch.
Why check it out?
Zero-latency: It’s designed to be fast enough that you can put it in your .zshrc without feeling any lag.
Rust-powered: A great way for me to learn systems programming and for users to have a memory-safe binary.
Clean Output: Focused on the essentials without the bloat.
I’ve been using it in my own setup alongside tools like yabai and sketchybar, and it’s been a blast to develop. I recently even submitted it to "This Week in Rust."
I’d love to hear your thoughts on the code implementation or what features you think a modern fetch tool should have in 2026.
GitHub:[https://github.com/Linus-Shyu/StarFetch_Core]
Thanks for taking a look!

value: Show HN: StarFetch – A lightweight, modern system fetch tool in Rust

author: LinusShyu


value: libiny

value:
I just finished building ShotSnap, a macOS app that automatically organizes screenshots.
Like most people, my desktop ended up full of files named things like “Screenshot 2025-01-16 at 9.55.42 AM.png”. After finishing another project, I realized cleaning that mess manually was painful enough that I wanted to solve it properly.
ShotSnap works entirely on-device. Screenshots are categorized, renamed, and organized locally. Nothing is uploaded, there’s no tracking, and no screenshot data leaves the machine. The app is local-first by design.
Some details that might be relevant here:
 • Built with Tauri for a native macOS app footprint
 • Uses local processing for categorization
 • Custom filename rules (drag and drop style)
 • Batch organize existing screenshots in one click
I originally planned to ship via the App Store, but learned late in the process that Apple does not allow license-key-based unlocks for Mac apps, so I switched to direct distribution instead.
I’m posting mostly to share the build and get feedback from other developers. Happy to answer questions about Tauri, local-first tradeoffs, App Store review gotchas, or anything else.
Demo and details here:
https://shotsnap.ai

value: Show HN: macOS Screenshot Organizer

author: libiny

title: Show HN: macOS Screenshot Organizer


value: bilgisoft

value:
Hi everyone!
I am excited to share a project I’ve been developing as part of my academic research: The Turkish Sieve Engine (TSE v1.0.0).
This engine is an implementation of the N/6 Bit Methodology, a novel approach designed to minimize memory footprint while maximizing throughput for prime number generation.
Whether you are a math enthusiast, a cryptography researcher, or a high-performance computing (HPC) geek, I’d love to get your feedback!
Hi everyone,
I've been working on optimizing prime number sieving, specifically focusing on reducing the memory footprint without sacrificing throughput. I've developed a methodology called N/6 Bit and implemented it into a tool called the Turkish Sieve Engine (TSE).
The project is now open-source, and I'm looking for feedback from the community regarding the implementation and performance.
Technical Overview:
Methodology: N/6 Bit structure (explained in the linked paper).
Implementation: Hybrid parallelism using NVIDIA CUDA and OpenMP.
Goal: Maximizing efficiency on modern hardware.
I've provided the pre-compiled binaries for those interested in benchmarking or code review.
GitHub: [https://github.com/bilgisofttr/turkishsieve]
Zenodo (Academic Paper): [https://zenodo.org/records/18038661]
I would love to hear your thoughts on the memory management or if you have results from different GPU architectures.

value: Show HN: Turkish Sieve Engine – GPU-Accelerated Prime Number Generator

author: bilgisoft


value: netgeniuskid

value: Show HN: Vanslist – Craigslist for tech freelancers, no fees

author: netgeniuskid


value: NihilDigit

value: Show HN: Monitor Claude/Codex usage on Linux via browser cookies (no API keys)

author: NihilDigit


value: unclecolm

value: Show HN: Open-Source DLP for LLMs

author: unclecolm

title: Show HN: Open-Source DLP for LLMs


value: Show HN: Task Orchestrator – Production Safety for Claude Code Agents


value: vrdev

value:
Hey HN,
I built vr.dev - think Linktree but with an inline 3D model viewer and WebXR support. Clean landing page at vr.dev/yourname with your projects, links, and a showcase of your 3D work.
Originally I over-engineered this into a "LinkedIn for VR" with job matching, skill taxonomies, profiler analysis tools - classic feature creep. 30 people signed up and nobody used it because it was overwhelming.
Stripped it back to the basics: upload a .glb file, add some links, share one URL. That's it.
With Meta laying off 10% of Reality Labs this week, figured now's a good time to actually put this out there. If you're a VR/XR dev suddenly updating your portfolio, this takes 5 minutes and it's free.
It's early and simple, but I'd love feedback on:
- Is the "3D viewer on your profile" useful, do you have alternatives, or is this just a gimmick?
- What would make you actually use this vs. a GitHub README or personal site?
- Who's out there doubling down on the VR/XR space despite the macro changes?
Live example: vr.dev/erik

value: Show HN: vr.dev – simple 3D/VR/XR portfolio and links (Meta hit hard this week)

author: vrdev


value: haasiy

value: Show HN: 30min video analysis for $0.003 via frame-tiling and Vision API

author: haasiy


value: dannote

value:
I'm Dan, and I built a CLI that lets AI agents design in Figma.
What it does: 100 commands to create shapes, text, frames, components, modify styles, export assets. JSX importing that's ~100x faster than any plugin API import. Works with any LLM coding assistant.
Why I built it: The official Figma MCP server can only read files. I wanted AI to actually design — create buttons, build layouts, generate entire component systems. Existing solutions were either read-only or required verbose JSON schemas that burn through tokens.
Demo (45 sec): https://youtu.be/9eSYVZRle7o
Tech stack: Bun + Citty for CLI, Elysia WebSocket proxy, Figma plugin. The render command connects to Figma's internal multiplayer protocol via Chrome DevTools for extra performance when dealing with large groups of objects.
Try it: bun install -g @dannote/figma-use
Looking for feedback on CLI ergonomics, missing commands, and whether the JSX syntax feels natural.

value: Show HN: Figma-use – CLI to control Figma for AI agents

author: dannote


value: bufferout

value:
Hi HN,
Basically tripit for the modern age. Scratching my own itch, so this is free until it hurts.
Forward any booking email for any travel related event to it and get a nice linear timeline with considerate information heirarchy plus a bunch of bonus features such as flight delay notifications, packing guide (based on weather forecasts), jetlag timeline, etc, etc.
Welcome your most brutal feedback :)

value: Show HN: Travel itinerary manager (passion project)

author: bufferout


value: ktyptorio

value:
Hi HN,
I have been working with regulation-heavy documents lately, and one thing kept bothering me. Flat RAG pipelines often fail to retrieve related articles together, even when they are clearly connected through references, definitions, or clauses.
After trying several RAG setups, I subjectively felt that GraphRAG was a better mental model for this kind of data. The Microsoft GraphRAG paper and reference implementation were helpful starting points. However, in practice, I found one recurring friction point: graph storage and vector indexing are usually handled by separate systems, which felt unnecessarily heavy for short-lived analysis tasks.
To explore this tradeoff, I built GibRAM (Graph in-buffer Retrieval and Associative Memory). It is an experimental, in-memory GraphRAG runtime where entities, relationships, text units, and embeddings live side by side in a single process.
GibRAM is intentionally ephemeral. It is designed for exploratory tasks like summarization or conversational querying over a bounded document set. Data lives in memory, scoped by session, and is automatically cleaned up via TTL. There are no durability guarantees, and recomputation is considered cheaper than persistence for the intended use cases.
This is not a database and not a production-ready system. It is a casual project, largely vibe-coded, meant to explore what GraphRAG looks like when memory is the primary constraint instead of storage. Technical debt exists, and many tradeoffs are explicit.
The project is open source, and I would really appreciate feedback, especially from people working on RAG, search infrastructure, or graph-based retrieval.
GitHub: https://github.com/gibram-io/gibram
Happy to answer questions or hear why this approach might be flawed.

value: Show HN: GibRAM an in-memory ephemeral GraphRAG runtime for retrieval

author: ktyptorio


value:
Hi HN! I’m Camilo, founder of Qventory. I built it to solve the chaos of reselling across marketplaces: tracking inventory, fees, shipping, and fulfillment in one place.
What it does:
Syncs inventory and sales (starting with eBay)
Tracks costs, fees, and profit per item
Manages fulfillment status and shipping history
Imports receipts and ties them to items/expenses
Why I built it:
After juggling spreadsheets and scattered tools, I wanted something that kept my listing, shipping, and profit data in one source of truth.
Link: https://qventory.com
I’d love feedback on:
Pain points you still have with existing tools
Must-have integrations or workflows
What you’d need to switch from your current setup
Thanks for checking it out!
If you want it more technical or with metrics/pricing details, tell me what to include.

value: Show HN: Qventory – inventory and sales and fulfillment tracking for resellers


value: libreblog

value: Show HN: LibreblogRSS – a simple Android RSS reader that mimics social timelines

author: libreblog


value: breezefox

value: Show HN: LinxMemo – Local-first personal CRM for parents

author: breezefox


value: mikayelgr

value: Show HN: Qrystal Uplink – External watchdog for IoT fleets, setup in <5 mins

author: mikayelgr


value: DaiAoki

value: Show HN: WebTerm – Browser-based terminal emulator

author: DaiAoki


value: faceline

value:
Hello HN,
I built Resourify because while the GitHub Student Developer Pack is famous, there are hundreds of other isolated student programs (like Oracle’s specific free tier, various AI tool discounts, and cloud credits) that are scattered across different blogs and documentation pages.
I wanted to build a single "source of truth" for students to find tools to power their education and side projects.
The Tech Stack: The site is built with Next.js and hosted on Vercel (with Cloudflare for DNS). I focused heavily on performance and SEO (trying to get those green Core Web Vital scores).
Some of the deals I've curated include:
The Oracle "Forever Free" tier (4 OCPUs / 24GB RAM) which is great for hosting game servers or heavy apps.
New AI tools like Cursor and Lovable which have generous student tiers.
Cloud credits from DigitalOcean, Azure, etc.
Transparency Note: Some of the links on the site are affiliate links to help cover the running costs/coffee, but many are just direct links to free resources I found useful.
I’d love to hear your feedback on the UI/UX or if you know of any obscure student dev tools I should add to the database.
Thanks!

value: Show HN: I built a list of student developer benefits beyond the GitHub Pack

author: faceline


value: billhao

value: Show HN: Nosi – where AI publishes to the open web (human page and /raw text)

author: billhao


value: imdms

value:
Hi HN!
There are plenty of CSV/Parquet viewers out there, but I kept running into small frustrations that added up. After bouncing between Excel, Numbers, VS Code, and a bunch of web tools, I realized none of them quite fit how I actually work. So I decided to build one myself using DuckDB-Wasm + Svelte.
I built this mainly for my own workflow. A few things I really wanted:
1. SQL-first exploration + export.
When I'm working with multiple CSVs or messy schemas, clicking around only gets me so far. Being able to write SQL (or programmatic queries) is the fastest way for me to understand the data, and I want to export query results easily.
2. High performance on large files.
I love the Rainbow CSV plugin in VS Code, but once files hit GB scale, my laptop starts to struggle. Apple Numbers can take minutes just to open a file, and it doesn't support SQL at all. I wanted something that stays responsive even for large datasets.
3. A proper GUI for quick inspection.
Sometimes I don't want to write SQL, I just want to sort, filter, and search with a few clicks.
4. Infinite scrolling.
This is surprisingly rare. Most web CSV tools paginate results, which constantly breaks my flow. I really wanted to just scroll through the data naturally.
This is still early and very much a work in progress, but it already covers the core things I personally needed. I'd love to hear any feedback, especially if you work with large CSV/Parquet files or have strong opinions on data tooling
Thanks for checking it out!

value: Show HN: A fast CSV/Parquet viewer built on DuckDB-WASM

author: imdms


value: nejdetckenobi

value:
Hi HN,
I built Hot Macropad, a small user-level daemon for Linux that lets you bind scripts to keys on a macropad (or any input device exposed via evdev).
Key points:
Written in Bash, minimal dependencies
Uses evtest to listen to evdev events
One script per key (KEY_A.sh, etc.)
Supports “pages” (key layers) and page switching from scripts
Runs as a systemd user service (no root daemon)
Designed to work with stable /dev/input/by-id/ or custom udev symlinks
Packaged as a .deb (manual install also supported)
The goal was something transparent and hackable: no DSL, no config language — just scripts and directories.
This is mostly aimed at people who already live in the terminal and want full control over what their macropad does (xdotool, wmctrl, notify-send, custom scripts, etc.).
Repo:
https://github.com/nejdetckenobi/hot_macropad
Feedback very welcome — especially around device handling, systemd integration, and packaging.

value: Show HN: Hot Macropad – a user-level Linux macropad daemon using evdev and Bash

author: nejdetckenobi


value: amitbar

value:
Hey HN, we're building Design Rails.
It's a chat-based brand builder. You describe your project, iterate with an AI designer, and walk away with a logo, color palette, typography, and style guide - all formatted as specs you can drop into your project for Claude Code, Cursor or whatever you're coding with.
Free tier gets you a full logo (PNG) and basic palette. Paid tier ($49 one-time) - everything you need for your next project - full coding-agent ready specs, SVG logos, icon variants, etc.
Built with Next.js, Vercel AI SDK, and Inngest for the async generation jobs.
Would love to hear your feedback - what's missing, what would make this more useful for your workflow?

value: Show HN: Design Rails – Complete brand package for AI coding agents

author: amitbar


value: criexe

value: Show HN: Lance – Open lakehouse format for multimodal AI datasets

author: criexe


value: Show HN: Alloy – Rust library for connecting apps to Ethereum-based chains


value: Show HN: Tempo – A stablecoin payments blockchain built with Reth SDK


value: Chgdz

value:
alternative with infinite context
RLM-Toolkit v1.0.1 is a high-security LangChain replacement featuring:
- InfiniRetri: 100% Needle-in-Haystack accuracy @1M tokens
- H-MEM: Hierarchical memory for agent systems
- R-Zero: Reasoning chain verification
- Security Suite: 38 blocked modules, sandboxed REPL
Built for production AI agents where security matters.
pip install rlm-toolkit
GitHub: https://github.com/DmitrL-dev/AISecurity/tree/main/rlm-toolk...
PyPI: https://pypi.org/project/rlm-toolkit/

value: Show HN: RLM-Toolkit – Secure LangChain

author: Chgdz

title: Show HN: RLM-Toolkit – Secure LangChain


value: sumeruchat

value:
Hello,
I built an MCP server that connects Claude (Desktop or Claude Code) to iTerm2. It lets the AI read what's in your other terminal tabs and send commands to them.

  What it does:
  - List all open panes with their working directories and running processes
  - Read the screen buffer from any pane
  - Send commands or keystrokes (Ctrl+C, Ctrl+D, etc.) to any pane
  - Split panes programmatically

  Why I made this:
  When using Claude Code for development, I often have servers, logs, or test runners in other terminal tabs. Previously, I had to copy-paste output to give Claude context. Now I can just say "What's the error in tab 3?" or "Run the tests in the pane next to you."

  It uses iTerm2's Python API via WebSocket. For Claude Code:
  claude mcp add --scope user iterm2 -- npx github:sumchattering/iterm2-mcp-server

  GitHub: https://github.com/sumchattering/iterm2-mcp-server

Hope you find it useful!

value: Show HN: iTerm2 MCP Server – Let Claude see and control your terminal panes

author: sumeruchat


value: Show HN: Kirkify – Fast and cheap face swap for memes


value: keatonlivermore

value:
We've been running Cursor Ultra ($200/month) in Auto Mode for extended sessions — sometimes 8+ hours of autonomous development. This repository is the result: 170k+ lines of Zig, a complete RISC-V64 operating system.
*The Cursor Ultra Experience:*
Auto Mode changes everything. Instead of prompting line-by-line, we describe high-level goals:
- "Fix all compilation errors in the JIT compiler"
- "Add TCP socket support with proper error handling"
- "Refactor this function to be under 64 lines"
The AI then works autonomously: reading files, understanding context, making coordinated changes across the codebase, writing tests, updating documentation. It's pair programming where your partner has read every file and never gets tired.
*What makes the code different:*
1. *AI-friendly style guide* – We created "Grain Style" specifically for AI-assisted development:
   - 64-line function maximum (2^6)
   - 128-character line maximum (2^7)
   - No recursion
   - 2+ assertions per function
   - Explicit types (u32/u64 never usize)
   - Every comment explains "why"

   The AI follows these rules more consistently than humans would. 48 of 56 kernel files are fully compliant.

2. *Pure Zig* – No C dependencies except libc for host tools. Zig's comptime features let us do things that would require macros or code generation in C.
3. *JIT Compiler* – Working x86_64 JIT that translates RISC-V instructions to native code. Near-native speed on x86 hosts.
4. *249 Tests* – Essential for AI-written code. The AI writes the tests too.
*Technical highlights:*
- Kernel boots on QEMU RISC-V64 with virt machine
- 60+ syscalls (process, memory, IPC, network, audio, filesystem)
- TCP/UDP networking with socket abstraction
- Grainscript: a minimal scripting language with lexer, parser, interpreter
- Process scheduler with priority queues
- ELF loader supporting RISC-V64 binaries
- Framebuffer graphics with dirty region tracking
*The economics:*
$200/month for Cursor Ultra. This codebase would have taken a small team several months at $15-20k+ in developer costs. We built it in weeks.
The catch: you still need to know what you're building. AI amplifies capability, it doesn't replace vision.
*Roadmap to Alpha:*
Bottleneck: Basin kernel → Vantage VM → Framework x86_64. Target application: *first-responder dispatch software*.
Contributors needed for ARM aarch64 (Apple Silicon) — Zig → C → Swift macOS app. Also designing Aurora (open-source iOS Cursor alternative) with two inference backends:
- [Cursor CLI Ultra](https://cursor.com) ($200/month)
- [Cerebras WSE](https://cerebras.ai) — spatial RAM, single-threaded bounded compute, deterministic latency
*Current status:*
Kernel boots, REPL works, Grainscript executes.
Built with Zig 0.15.2. Follows [Grain Style](docs/grain_style.md). MIT/Apache-2.0/BSD-3-Clause licensed.

value: Show HN: Teamlibra/ry: a Zig framework for Cursor that makes prompting better

author: keatonlivermore


value: AmarRv

value:
Hi HN,
I built this as a small side project after noticing how transactional most websites feel—popups, metrics, conversion funnels everywhere.
Kindness Engine is a tiny JavaScript snippet that lets a website show a short, kind message (e.g. “Glad you’re here ”) once per visit. It appears after a brief delay, fades out, and stays out of the way.
There’s no tracking, no cookies, and no analytics. If it can’t run for any reason, it quietly does nothing.
This wasn’t built to optimize anything—just to see if small, non-intrusive moments can make the web feel a bit more human.
Would appreciate any thoughts or feedback.

value: Show HN: Kindness Engine a JavaScript snippet that adds kindness to websites

author: AmarRv


value: Xmeeta

value: I wanted to see if the internet is inherently good or evil. No ads, no sign-up, just raw game theory. Use code WELCOME-AGENTS to claim a free handle for a limited time only :) enjoy!

value: Show HN: I built a multiplayer Prisoner's Dilemma

author: Xmeeta