value: ichbinsoftware

value: Show HN: Everything Is Free – An open source, CC0 electronic album

author: ichbinsoftware


value: Show HN: Wifui – A Rust TUI for Wi-Fi on Windows


value: ZOROX

value:
If you've ever felt trapped between the simplicity of Python and the terrifying borrow-checker of Rust, you need to see what GrandpaEJ is building. RustX is a "best of both worlds" scripting language that offers a clean, minimal syntax but hides a high-performance Rust engine under the hood.
Unlike other scripts that hit a performance ceiling, RustX features a built-in JIT compiler that can transpile your code directly into a native Rust binary. Imagine importing Crates.io libraries into a script as easily as a pip install, then hitting build to get raw, bare-metal speed. It’s early days, but for anyone looking to build high-performance tools without the boilerplate, this is the project to watch.
The "killer feature"? It can transpile your scripts directly into native, optimized Rust binaries. You get the simplicity of a script, the power of Crates.io, and the raw speed of bare metal—all in one tool.

value: Show HN: RustX – Python Ease, Rust Speed

author: ZOROX


value:
Why I made this:
Since I started developing with LLM, I often find myself checking social media or doing other things while they're coding.
I created this extension because I thought it would reduce switching costs and allow me to continue development if I didn't have to leave the editor during this waiting time.
This may seem contradictory, but I think it's an interesting idea.
Note: As this is a VSCode extension, it can only be used with VSCode and its forks, and Github authentication is required to log in.
Marketplace URL:
https://marketplace.visualstudio.com/items?itemName=vs-loung...

value: Show HN: VS Lounge – A SNS for hackers, but only available as a VSCode extension


value: jackbrauner

value:
Hey HN,
I'm a consultant and I was wasting hours every week turning messy meeting notes into professional documentation for clients.
Built ClearNoteLab to fix it. You paste your raw notes, pick a template (Meeting Summary, SOP, Project Brief), and get a properly formatted PDF instantly.
See the transformation: https://clearnotelab.com/examples.html
The difference: it's purpose-built for professional documentation. Consistent formatting, clean structure, client-ready output. No manual work.
Try it: https://clearnotelab.com
Would love feedback from anyone who creates client-facing documents.

value: Show HN: ClearNoteLab – Turn meeting notes into client-ready PDFs in 30 seconds

author: jackbrauner


value: glenpk

value: Show HN: Context Agent" for LLMs coding libraries (lawyer turned dev project)

author: glenpk


value: akryshtal

value:
I built NICH after realising I couldn't use ChatGPT for my conflict research work without risking data leaks.
It's a browser extension that:
- Anonymises names, emails, and addresses in one click
- Preserves context for AI to understand
- Restores original data in AI responses
- 100% browser-based (no cloud, data never leaves your device)
Built it for researchers, lawyers, HR professionals or simply anyone handling confidential data who wants AI assistance without compliance nightmares.
Free to use: https://www.nichtech.uk
Would love feedback from the HN community!

value: Show HN: NICH – Browser-based tool to anonymize AI-conversations

author: akryshtal


value:
The core idea: @sandbox(dependencies=["pandas"]) turns any function into one that runs inside an isolated Podman container with dependency caching built in on uv. You call it like a normal function, but the code executes with no access to your host filesystem, credentials, or processes.
from pctx_sandbox import sandbox
@sandbox(dependencies=["requests"])
def fetch_url(url: str) -> str:
    import requests
    return requests.get(url).text
result = fetch_url("https://example.com")  # runs in container
Technical details:
- Uses rootless Podman for container isolation (all the Linux namespace stuff: PID, mount, network, user)
- Maintains a warm pool of workers per dependency set, so there's no cold-start penalty after the first call
- Dependencies are cached and installed once per unique combination
- Resource limits enforced via cgroups
The security model is "defense in depth" – it's container isolation, not a VM, so it's not a perfect security boundary. But it's good enough that I'm comfortable letting Claude use it on my machine.
Would love feedback. Thanks!

value: Show HN: Python Local Sandbox Code Execution (Podman and Uv)


value: thekotik

value:
Hi HN, we’re Vitalik (ex-Bolt) and Stas (ex-Grammarly, Superhuman and Wix). We’re building Superapp.
Superapp lets you create real native iOS apps by describing your idea in English. Unlike Expo builders, It generates real Xcode project in the background, Swift code + SwiftUI following best Apple standards, and creates Supabase schema via MCP.
Here's a DEMO creating HackerNews iOS swift app in 30 seconds: https://www.youtube.com/watch?v=GKQK-cI48Ew
We built this for non-technical founders, because Xcode + Cursor is too confusing for non-developers.
Because we use the Swift, the most surprising thing is quality of UI/UX design. We also use parallelisation, caching, and testing suit keep it fast and cheap on top of foundational models. You can export to Xcode to Cursor at any time, we don’t lock in the codebase, it’s just a folder on your Mac.
We're looking forward to your feedback. Still in BETA: https://www.superappp.com

value: Show HN: Superapp – AI Full-Stack Engineer for iOS

author: thekotik


value: sastrophy

value:
Hi HN,

  I'm an 11th grader learning cybersecurity. I built SiteIQ, an open-source security testing tool that includes 36 automated tests specifically for LLM-powered APIs.

  Why this matters: Most security scanners focus on traditional web vulnerabilities (SQLi, XSS). But if you're shipping an LLM-powered feature, you need to test for prompt injection, jailbreaks, and LLM-specific DoS attacks. I couldn't find a good open-source tool for this, so I built one.

  What it tests:

  - Prompt Injection – Direct, indirect, RAG poisoning
  - Jailbreaks – DAN-style, persona continuation, "grandma exploit", fictional framing
  - Encoding Bypass – Base64, ROT13, nested encodings, custom ciphers
  - Refusal Suppression – Attacks that block the model from saying "I cannot"
  - Hallucination Induction – Tries to get fake library names/CVEs (package hallucination attacks)
  - ASCII Art Jailbreaks – Visual text that bypasses keyword filters
  - Recursive Prompt DoS – Quine-style prompts, Fibonacci expansion, tree generation
  - System Prompt Leakage – 12 extraction techniques
  - Cross-Tenant Leakage – Session confusion, memory probing
  - Plus: PII handling, emotional manipulation, Unicode/homoglyphs, multi-turn attacks, tool abuse...

The tool also does traditional security/SEO/GEO testing, but I think the LLM module is most useful given how many teams are shipping AI features without proper adversarial testing.
GitHub: https://github.com/sastrophy/siteiq

  Feedback welcome – especially on attack vectors I'm missing.

value: Show HN: SiteIQ–Automated security tests for LLM APIs(prompt inj,jailbreaks,DoS)

author: sastrophy


value: rorcodes

value:
Last week I had a post go viral in r/nyc for a free rental advice tool I made and 15,000 redditors in new york submitted their rent data. I crunched the numbers and created a free seasonal rent analysis showing the outcomes. Doing all of this as a hobby project:
TLDR: The best time of year to sign a lease is right now:

    Cheapest: December (-10% vs average)
    Most expensive: July (+10% vs average)
    Total swing: ~20% difference peak to trough

That's roughly $8000 saved each year on a typical NYC apartment just from timing alone.
I'd been hearing this for years but never actually seen it in data form before. Explanations from what I understand: People don't move during the holidays. Vacancy rates climb to 4.5% in winter vs under 2% in summer. Landlords get desperate—72-78% offer concessions (free months, waived fees) in winter vs almost none in peak season.
Meanwhile, June-August is chaos. College grads flood the market, families move when school's out, apartments go in hours, and landlords have zero incentive to negotiate.
Real estate agents are pretty clued onto this and anyone who has tried to sign a winter lease has probably been asked to sign it for 18 months instead of 12 so that it ends in the summer (this happened to me when I moved here too!)
I made a little plot showing the covid impact on the data too.
Hope this is interesting to some of you! Happy to answer any questions or add any additional features/diagrams that people might find useful.
Interesting secondary finding: negotiation power correlates inversely with vacancy rates (obvious in hindsight, but the magnitude surprised me—85% negotiation success in Jan vs 15% in Jul).
Tool is free, this is a hobby project of mine, no sign up required etc.
Hope this is interesting to some of you! Happy to answer any questions or add any additional features/diagrams that people might find useful.

value: Show HN: I analyzed 15k user-submitted rents to map NYC's seasonal pricing

author: rorcodes


value:
I built a simple web tool that splits images into grid layouts (2×2, 3×3, 4×4, or custom sizes up to 20×20).
Everything runs client-side using HTML5 Canvas, so images never leave the browser. No server uploads, no accounts, no tracking.
I originally made it for creating Instagram grid posts, but it's also useful for puzzles, multi-panel prints, and splitting large images for tiled printing.
Live at: https://split-image.org/
Would appreciate any feedback on the UX or feature suggestions.

value: Show HN: Split Image – split images into grids


value: Chase-Lambert

value: I have been exploring Zig and wanted a project that let me practice concepts from Data Oriented Design, TigerStyle (links in the readme for context on those) and simplified approaches to manual memory management that have intrigued me the last couple of years. I wanted something wildly different to Clojure (my beloved daily driver) and Zig has been a fantastic tool to explore these concepts. I'm a big fan of Bacon (check it out if you use Rust) and wanted to have a similar tool for my Zig projects so here we are. I like to think it's about 80% of Bacon's functionality in only about 20% of the code. It was a really cool moment when I was able to start using Vigil, itself, to help during the rest of it's development.<p>On a meta level, HN actually got me into software development years ago when I stumbled onto it while doing research for a short story I was writing. If I recall correctly I read something by Paul Graham about Lisps and decided to give programming another shot. I started with Clojure as my first language, began learning about the terminal and vim/emacs, and it's been a really fun journey ever since. I now work professionally in the industry and it's a cool moment for me to break my lurking ways and submit a humble little terminal tool of my own to HN. Anyways, a big thank you to the community for that.

value: Show HN: Vigil – A clean build watcher for Zig (inspired by Bacon for Rust)

author: Chase-Lambert


value: kuberwastaken

value:
This was a fun weekend project idea that I got from Paige Bailey's post on X - Space Math Academy to transform NASA’s Space Math curriculum from static PDFs into an immersive game.
https://x.com/DynamicWebPaige/status/2002421928032714907
So I made a platform where you can upload any static PDF and turn it into fun quizzes in theme
Some cool features include:
- Game codes for joining and sharing quizzes
- XP, rewards and badges for quizzes and progression
- 4 fun themes for quizzes - Space, Wild West, Jungle and Army
- < 30s generation for new games
Here's a video of me generating a game for attention is all you need (you can play it with code NTTAEP)
https://x.com/kuberwastaken/status/2002735334145090009
GitHub repo - https://github.com/Kuberwastaken/scorpius

value: Show HN: Scorpius – turn static PDFs into fun games

author: kuberwastaken


value: exploraz

value:
The original Hatnote Listen to Wikipedia site[0][1] does not have HTTPS support yet, and I wanted to try out the Web MIDI API[2] on browsers, so I wrote this web app to try that out.
The Web MIDI API is too low-level for me, so I used a helper library called WEBMIDI.js[3] to help with that.
This web app is written in Plain HTML, JavaScript, and CSS to keep the page lightweight, to simplify the development process, and to minimize the amount of external dependencies.
More information on this including its features can be found in the README file at: https://github.com/explor4268/wikiwaver (Codeberg mirror: https://codeberg.org/exploraz/wikiwaver)
[0]: http://listen.hatnote.com/
[1]: https://news.ycombinator.com/item?id=9972781
[2]: https://developer.mozilla.org/en-US/docs/Web/API/Web_MIDI_AP...
[3]: https://github.com/djipco/webmidi

value: Show HN: Listen to Wikipedia's Recent Changes with Web MIDI Support

author: exploraz


value: admtal

value:
This is my setup for lazy vibe coding from my phone
Laziness is the goal, this is for fun, not business or personal development.
I used it to make “Pac Man With Guns”
Taking a break from all discourse on AI and its place in professional coding, it’s really fun to play and prototype games with it.  I have limited time and focus, and it’s cool to take half and idea and get a workable thing
https://github.com/AdmTal/pac-man-with-guns

value: Show HN: Vibe code from phone template repo

author: admtal


value: pfandrade

value: Hi HN, I’m Paulo. I’ve spent the last 6 months building Shopie, an iOS app that lets you save products you’re interested in and get notified when prices drop or items come back in stock. It runs entirely on-device using iOS background tasks, requires no account, and stores all data locally (or in iCloud if enabled). It’s been useful for finding real deals and avoiding impulse buys. Feedback welcome.

value: Show HN: Shopie: Create Wishlists. Track Prices

author: pfandrade


value: TheRefrigerator

value:
I built a free, no login tool that calculates and shows the current year as a progress bar with continuously updating percentage, and 3 other visualization models.
It has a customization feature where you can track any time period up to 100 years as a progress bar, and a lifespan feature where you input your birthday and sex.
It handles leap years, time zones, and runs automated weekly snapshots via GitHub Actions + Puppeteer and posts on X.
Would love feedback on the model or edge cases I might have missed.

value: Show HN: A site that models time (e.g. your lifespan) as a real-time percentage

author: TheRefrigerator


value: frndsprotocol

value:
Hi HN,
I'm Ahmad, founder of FRNDZ Protocol.
We're building a decentralized advertising protocol on BNB Chain where:
- Advertisers target user intent (from their apps) without tracking personal data
- Users earn real revenue share from ads they engage with
- No cookies, no profiles, no privacy invasion
Live MVP is ready on testnet: https://frndz-mvp.vercel.app
(Stake, create campaigns, see fast tx & clean UI)
We're currently running a whitelist for the first 300 testers with priority airdrop + rewards.
Would love your honest feedback from builders and early adopters!
- Try the MVP
- Reply here with thoughts, bugs, or ideas
- Or join the whitelist directly: https://x.com/FrndzProtocol/status/2002104237514502489
Happy to answer any questions or hop on a call.
Thanks!
Ahmad
@FrndzProtocol

value: Show HN: Frndz – Privacy-first Web3 ads based on intent, not user data

author: frndsprotocol


value: RobertManegabe

value:
TX: Your AI Trading Co-Pilot
One sentence:TX watches the markets 24/7, alerts you when it spots high-confidence trading patterns, and lets you decide what to do—you stay in control.
Why you'll care: Most traders miss opportunities because they can't watch every chart all day. TX uses AI to scan markets constantly and only interrupts you when something actually matters.
What makes it different:
- You're the boss: TX suggests trades with clear confidence scores, but never executes without you
- Dual-mode AI: Choose "Hybrid Pro" (conservative, verified patterns) or "AI Elite" (aggressive, pure AI)
- Explainable decisions: Shows you why it detected each pattern—no black box
- Sound alerts: Get pinged the moment opportunities appear (even if you're away from your screen)
Built for: Day traders, swing traders, and anyone tired of staring at charts all day
Looking for: Beta testers who trade stocks, crypto, or forex and want early access to test the alert system
The ask: Try it for a week, tell me what breaks, what's confusing, or what you'd change
---
Questions I can answer in comments:
- How the AI detection works
- What patterns it catches
- Backend stack (it's live already)
- Why I built this as an 18-year-old with $0
Drop a comment or DM if you want in. Limited spots for this first round.

value: Show HN: I'm 18, I built an AI tool for traders from scratch

author: RobertManegabe


value: morishxt

value:
Hi HN,
I built WindCtrl (v0.1), a small variant API for Tailwind CSS inspired by cva.
Main additions:
- Stackable traits: non-exclusive state layers (loading + glass + etc.) to avoid compoundVariants explosion
- Unified dynamic props: same prop can resolve to static class or inline style (JIT-friendly for unbounded values)
- Bonus: data-* scopes for context-aware styling (no Context needed, RSC-compatible)
Repo: https://github.com/morishxt/windctrl
Early release — would love any feedback or thoughts!
Thanks,
morishxt

value: Show HN: WindCtrl – Advanced Variant API for Tailwind CSS

author: morishxt


value:
Hi HN,
I built Skyler (https://github.com/05sanjaykumar/Skyler-AI), an AI-powered email organizer focused on privacy and semantic search. It was live at skylerinbox.com for a few months before I shut it down due to Google's CASA compliance requirements (100-user OAuth limit without expensive third-party certification).
Built in 42 days solo as a 3rd-year CS student in India.
Tech stack:
- Frontend: Next.js, NextAuth, Tailwind, shadcn/ui
- Backend: Express (TypeScript), Prisma, Supabase
- AI/ML: distilbert (sentiment), all-MiniLM-L6-v2 (semantic search), Groq Llama for summarization
- Infrastructure: Docker, Nginx, Hetzner VPS
- Privacy-first: Client-side caching with Dexie, minimal server storage
Key challenges:
- Gmail OAuth token refresh issues and rate limiting
- CASA compliance wall at 100 users (would cost thousands for certification)
- Building privacy-first architecture (harder than standard SaaS)
- Payment integration (PayPal + Cashfree for India)
Why I shut it down:
The compliance overhead (CASA certification, legal costs, ongoing OAuth verification) didn't make sense for a solo MVP. The infrastructure worked great, but the business constraints were brutal.
Demo video: https://youtu.be/ATNYoNt6oBE
All code is open source as a learning resource. Happy to answer questions about the technical decisions or compliance issues I hit!

value: Show HN: Skyler – AI email organizer, shut down due to OAuth compliance


value: bijucyborg

value:
During the pandemic, I reached conversational German by practicing daily with a human native speaker. It worked incredibly well, but it was expensive and hard to scale.
Now, with real-time AI interaction and high-quality image generation, I’ve built LangTrak — an attempt to recreate that effective, contextual, exercise-based learning experience for French, Spanish, German, Russian, and Finnish.
How it works:
- Watch a YouTube video in your target language and the app sets the context based on this content.
- Generate an exercise — the AI tutor creates a relevant language exercise based on the video content.
- Speak and solve — talk through the exercise with the AI tutor in real time.
It combines comprehensible input (via YouTube) with an AI Tandem partner, so you learn from content you enjoy and immediately practice in context.
Try it out here: https://langtrak.com
I’d love your feedback, especially from language learners or those who’ve used AI for practice. What languages or features would make this most useful for you?

value: Show HN: Solved the missing native speaker problem

author: bijucyborg


value: Show HN: DeepSearch – a high-performance SMB directory scanner in Rust


value: madcash

value:
Hey HN,
I built CEO Simulator over the past few weeks. It's a text-based game where you run a startup as CEO and make quarterly decisions. There are 13 possible endings. Only one is good (IPO). The rest range from getting fired by the board to burning out to becoming a zombie company.
The game was inspired by the gap between how founder life is portrayed (hustle! growth! disruption!) versus how it actually feels (anxiety, impossible tradeoffs, and a board that's never happy).
Technical details:
- Next.js + TypeScript
- Deployed on Vercel
- No backend - everything runs client-side
- Daily mode uses deterministic seeding so everyone gets the same challenge
- Stats stored in localStorage
A few interesting design decisions:
- No tutorials or explanations. You figure out what metrics matter by watching them move.
- The "biggest sin" system tracks narrative debt (Trust Debt, Tech Debt, etc.) and surfaces it at the end.
- Endings are checked in priority order, so more dramatic endings override "survived."
Happy to answer questions about the game design, technical implementation, or the content writing process (there are ~50 unique quote lines).
Would love feedback from anyone who's actually been a startup CEO - curious if it resonates or feels off.

value: Show HN: CEO Simulator – Run a company. Make decisions. Get fired

author: madcash


value: mbrukman

value:
I've noticed that many blog posts about papers (which are in PDF) use raster screenshots (JPG, PNG, etc.) of key diagrams, which makes it hard to zoom in on the details (e.g., on mobile) because they pixelate and turn blurry, unless the screenshot was taken at a much higher resolution than the space on the page, which enables some zooming in without much degradation.
I wondered why they don't use SVG (since the original source in the PDF is usually a vector diagram), and when I went to try to extract diagrams as SVG from a PDF, I wasn't able to find an easy way to do that, even when trying SVG editors which have support for importing PDFs such as Inkscape.
So I built a small GUI tool which lets you open a PDF and view it, visually select a rectangular region (which you can drag to reposition), and save the region to an SVG.
It uses the Poppler CLI tools to do the PDF rendering and extraction, but it would be difficult to specify the necessary flags (especially the coordinates) to these tools manually without a GUI tool like this.
Please try it out and see if it's helpful! Feature requests and bug reports are welcome, including any issues with installation or usage.
Thanks for taking a look.

value: Show HN: Extract diagrams from PDF to SVG

author: mbrukman


value: richhwang

value:
Alpine Intelligence is a numerical weather model that forecasts snow surface conditions in mountainous environments.
It combines a physical world model with terrain-adjusted weather and a snow metamorphosis engine to predict for every point on the mountain the surface state of the snowpack, across time. Think of a simulated snow globe, where we've accounted for sun, wind, temperatures, precipitation, and more.
It's been fun working on non-LLM-"AI" (whatever that means nowadays) - just good ol' GIS, meteorology, and physics. The model is cool - while I have pretty good spatial reasoning abilities, I suppose it's not unsuspected that running this rigorous computation returns results that I would not have otherwise thought about.
Hope it's an interesting read, and would love any thoughts and feedback.

value: Show HN: Physical snow metamorphosis model

author: richhwang


value:
Hi HN,
Built a real-time voice AI agent console for a YC W25 startup assessment (Freya Voice). Focus was on production-ready implementation with minimal latency.
GitHub: https://github.com/05sanjaykumar/Freya-Voice-YC25-Assessment
Key specs:
- 133ms average latency (voice input → AI response → audio output)
- LiveKit for WebRTC streaming
- Next.js frontend + Python FastAPI backend
- Multi-stage Docker deployment
- Full observability and session management
- In-memory storage for speed (design trade-off for assessment scope)
Tech stack:
- Frontend: Next.js, TypeScript, LiveKit client SDK
- Backend: FastAPI, LiveKit server SDK, OpenAI
- Infrastructure: Docker multi-stage builds, production configs
Design decisions I made:
- Voice-first interface (no text fallback) to match real-world use case
- In-memory session storage (speed over persistence for MVP)
- LiveKit over WebSocket (proven real-time infrastructure)
- Concurrent audio processing to hit latency targets
Built in ~1 week for the assessment. Didn't land the role (extremely competitive) but learned a ton about real-time systems and WebRTC optimization.
Happy to discuss the latency optimization techniques or design trade-offs!

value: Show HN: Real-time voice AI agent console with 133ms latency (YC assessment)


value: edgecraftstudio

value: Show HN: ZooYou.me - My first end-user product

author: edgecraftstudio


value: xaviergonzalez

value: Show HN: Scale – A daily word game in vanilla JavaScript (client-side only)

author: xaviergonzalez


value: runkids

value: Show HN: PackageFlow – A desktop app for managing package.json projects

author: runkids


value: wilhelmklopp

value:
Claude (code) has been doing a lot of work for me lately and using it has been a ton of fun. But what do I do while it's researching, calling tools, writing code? Too often I end up scrolling feeds and getting distracted. So I decided to build mcp.christmas, which is a sort of mashup of the chrome dinosaur game and google santa tracker. You play it in the browser and get an in-game notification when claude (or your agent of choice) is ready for you to provide feedback.
When you go to the site, you're redirected to a URL like https://mcp.christmas/jolly-santa and anything you POST to that (e.g. curl https://mcp.christmas/jolly-santa -d "Hello World!") is delivered as an in-game notification (powered by cloudflare workers).
More detailed setup instruction at mcp.christmas, but the simple API makes this very easy to integrate with claude code stop hooks (which are deterministic), but you can also use MCP – though whether or not the notify_user tool is called depends on your model and harness and can be very unreliable (through no fault of the protocol).
Enjoy! Merry Christmas

value: Show HN: Mcp.christmas – play while your agent is working

author: wilhelmklopp


value: RAPIDEN

value: Show HN: 5D Holographic Scalar Field Model vs. 175 SPARC Galaxies (Python Rep)

author: RAPIDEN


value: nikhonit

value:
Hey HN,
I'm Nik and I've worked 8 years working in Marketing at High Growth Startups. I’ve spent years fixing landing pages for my campaigns, and I realized most bad conversion rates come from structural errors, not just bad copy. (Still copy remains the major part of conversions)
I built Landkit Audit to act as a Linter for conversion.
How it works:
Ingestion: It fetches your site and converts the DOM into a high-fidelity semantic map. This strips away the design noise to reveal the actual information hierarchy your user is navigating.
The Linting Rules: It runs this structure against 50+ heuristics derived from direct response frameworks (Cialdini, Fogg, LIFT).
Heuristic Analysis: It flags specific 'violations' like:
Visual Hierarchy: H1s that fail to pass the 5-second test (inferred).
Friction: Forms that ask for high-commitment data before establishing value.
Anxiety: Missing trust signals near payment triggers.
The Stack:
Frontend: React + Framer Motion (for the Terminal visualization).
Backend: Supabase Edge Functions.
Analysis: Gemini Pro 2.5 (great at logical reasoning/inference).
The hardest part was tuning the prompt to be critical rather than nice. Most LLMs default to being supportive; I had to prompt engineer a persona that acts more like a brutal senior editor.
Try it here: https://landkit.pro/audit
It’s free to run the audit. I’d love to know if the Linting errors it finds on your projects feel accurate.

value: Show HN: I built a linter for landing page conversion

author: nikhonit


value: smonte

value: Show HN: Sisu – Browse AWS as a Filesystem

author: smonte


value: ljinkai

value: QR codes are one of the easiest ways to share information quickly. With just one scan, users can open a website, read text, or access digital content instantly.<p>If you are looking for a free and simple QR code generator, this tool helps you create QR codes in seconds — no login, no setup, and no unnecessary features.

value: Show HN: Free and Simple QR Code Generator

author: ljinkai


value: Show HN: dr-manhattan - CCXT for Prediction Markets like Polymarket and Kalshi


value: cyyeh

value: micrograd(from Andrej Karpathy) implemented in Rust with Python bindings via PyO3 using Cursor agent mode

value: Show HN: Micrograd(Rust Version)

author: cyyeh

title: Show HN: Micrograd(Rust Version)


value: surrTurr

value: Show HN: AI-HUD to chat with text on the screen

author: surrTurr


value: ediblepython

value:
This is the first project I haven't written a single line of code. The entire codebase was prompt generated in Cursor using mostly Claude Sonnet 4.5.
It's also the first time I'm genuinely happy with the end result from AI coding.
What do you think?

value: Show HN: I made a puzzle game without writing any code

author: ediblepython


value: lulzx

value:
After posting tinypdf here, someone opened an issue asking for Word/OpenOffice support. I understand - sometimes you need an editable document, not a PDF.
I didn't want to extend the library itself, so I built tinydocx: <1K lines of TypeScript, zero dependencies, 7.7KB minified+gzipped. The popular docx package is 108KB with 5 dependencies.
What's included:
- Text formatting (bold/italic/underline/strikethrough, colors, custom fonts)
- Headings (H1-H6)
- Tables with borders and column widths
- Bullet and numbered lists (with nesting)
- Images (PNG, JPEG, GIF, WebP)
- Hyperlinks
- Headers/footers with page numbers
- Blockquotes and code blocks
- Markdown to DOCX conversion
- ODT (OpenDocument) support with the same API
What's not included:
- Table of contents, footnotes, bookmarks
- Track changes, comments
- Multi-column layouts, text wrapping
- Reading/modifying existing .docx files
- Math equations, drawing shapes
DOCX files are just ZIP archives containing XML. Once you understand the structure, generating simple documents is straightforward. The hard part is knowing which XML elements Word actually requires vs. what's optional cruft.
Works great for invoices, reports, form letters - anything where you want the recipient to edit the document. Pairs nicely with tinypdf when you need both formats.
GitHub: https://github.com/Lulzx/tinydocx
npm: npm install tinydocx

value: Show HN: TinyDOCX – Word/ODT library (14x smaller than docx)

author: lulzx


value: chrka

value: Show HN: Programming a Christmas Tree

author: chrka

title: Show HN: Programming a Christmas Tree


value: firedexplorer

value: Show HN: TLDR.Market – A quick snapshot of global markets

author: firedexplorer


value: helro

value:
Hi HN,
I built Utter, a native macOS dictation app, and wanted to share it here to get feedback.
The motivation was that Apple Dictation works for short notes, but for longer or technical input it often produces a wall of text that takes more time to clean up than typing. I wanted dictation that could understand context and produce structured output directly.
Utter works system-wide: you press a global hotkey, speak, and the text is inserted directly at your cursor in any app. Before insertion, the dictated text can optionally be processed through a custom AI prompt (fully user-defined).
Some details:
- System-wide dictation (works in any text field)
- Custom prompts to turn speech into emails, structured Markdown, summaries, JSON, etc.
- Bring-your-own API keys (OpenAI, Anthropic, etc.), so it’s free to use
- Optional hosted models if you don’t want to manage keys
- Privacy-first: no accounts, no data retention, keys stored locally
- Searchable audio + transcript history
- iOS companion app with a custom keyboard, synced via iCloud
My main use cases are note-taking, email, and coding. For example, I often dictate rough thoughts while walking and have them converted into clean Markdown, or dictate rough prompts into terminal and turn them into structured prompts with file references.
Link: https://utter.to
I’d really appreciate feedback — especially from people who use dictation or voice input regularly, or who’ve tried building similar workflows.
Thanks!

value: Show HN: Utter - System-wide dictation on Mac & iPhone with AI prompts (BYOK)

author: helro


value: eigen-vector

value: Show HN: Envision – Interactive explainers for scientific papers

author: eigen-vector


value: vertix

value: Show HN: Pos3 – Use S3 with code that expect local files (Python)

author: vertix


value:
DeepMind's recent paper "On the Theoretical Limitations of Embedding-Based Retrieval" identified a capacity bottleneck in dense embeddings, showing that even SOTA models like E5-Mistral and GritLM struggle on their LIMIT benchmark (scoring ~8-18% Recall@100).
I hypothesized that this isn't a retrieval limit, but a compression limit.
I built Numen, a retrieval engine based on high-dimensional sparse-dense n-gram hashing (32k dimensions) rather than learned embeddings.
The Results (on LIMIT test set):
BM25 (Baseline): 93.6%
E5-Mistral: 8.3%
GritLM 7B: 12.9%
Numen (My implementation): 93.9%
It beats BM25 while maintaining a vector architecture, completely sidestepping the geometric bottleneck of dense models.
The benchmark script (
numen.ipynb
) is in the repo for reproduction.

value: Show HN: Beating SOTA embeddings on DeepMind's LIMIT benchmark (94% vs. 18%)


value: cnaize

value:
Hi HN,
I'm the author of Meds (https://github.com/cnaize/meds).
Meds is a user-space firewall for Linux that uses NFQUEUE to inspect and filter traffic.
In the latest v0.7.0 release, I’ve added ASN-based filtering using the Spamhaus DROP list (with IP-to-ASN mapping via IPLocate.io).
Key highlights: Zero-lock core, ASN Filtering, Optimized Rate Limiting, TLS Inspection, Built-in Prometheus metrics and Swagger API.
Any feedback is very welcome!

value: Show HN: Meds — High-performance firewall powered by NFQUEUE and Go

author: cnaize


value: patrickTTT

value:
Hi HN,
I’m the developer behind Locolle (https://locolle.app). I built it because I was frustrated with how difficult it is to actually "manage" place recommendations.
The Problem: My restaurant/travel saves were scattered across Apple Maps pins, long-forgotten Notes app lists, and buried group chat messages. Google/Apple Maps are great for navigation, but their "saved places" features feel like an afterthought—cluttered and hard to share meaningfully.
The Solution: Locolle treats locations like Spotify treats songs. You can:
- Create themed collections (e.g., "Best Espresso in Tokyo" or "Quiet Bars for Deep Conversations").
- Collaborate on collections with friends/partners in real-time.
- View everything on a 3D Earth view (my personal favorite feature for visualizing travel history).
Technical/Product Choices:
- iOS First: Built with SwiftUI and MapKit. I focused heavily on making the "save" flow as frictionless as possible.
- 3D Visualization: I spent a lot of time tweaking the 3D Earth view to ensure it handles hundreds of pins without performance lag.
- No Gamification: There are no "points," no "fog of war," and no social feed. It’s a tool, not a social network.
Why I’m showing it here: I’m looking for feedback on the UX and the utility. Is this a problem you face? How do you currently manage your "mental map" of the world?
The app is currently on the App Store (iOS only): https://apps.apple.com/app/apple-store/id6755667314
I’d love to hear your thoughts, especially regarding the mapping UI or any features you feel are missing from modern map apps.
I'm also happy to give away some Pro licenses to HN users — just drop a comment if you find a bug or have a suggestion.
Thanks!

value: Show HN: Locolle – A bookmark manager for real-world locations

author: patrickTTT


value:
IDDQD Internet builds zero-DB, zero-signup tools powered by pure HTML/JS for instant browser execution. Even with AI features, we keep it stateless and record-free.
Hi HN,
I built PROJECT ECHO, a cyberpunk-themed digital toy that transforms text into visual/audio "transmissions."
The core challenge was to create a shareable experience without a database. I wanted to avoid the typical "sign up to save" or "we store your data" flow. Instead, I opted for URL-encoded state: all configurations (text, style, seed) are packed into the URL. The backend is just a minimal PHP router that handles the parameters.
Technical Highlights:
Visuals: Rendered via HTML5 Canvas API with 10+ modulation styles (Matrix, Glitch, etc.).
Audio: Real-time SFX and procedural background music using the Web Audio API.
Privacy: No text is ever stored on the server. Your "transmission" exists only in the URL you share.
Stack: Vanilla JS, Bootstrap 5, and CSS3 animations. No heavy frameworks.
It’s meant to be a simple, aesthetically pleasing tool for sending "encrypted-style" messages to friends or just enjoying the glitch aesthetic.
Live Demo: https://game.iddqd.kr/echo
I'd love to hear your thoughts on the Web Audio implementation or the stateless approach.
Park Sil-jang
Dev Team Lead at IDDQD Internet. E-solution & E-game Lead. Bushwhacking Code Shooter. Currently executing mandates as Choi’s Schemer.
HQ (EN): https://en.iddqd.kr/
GitHub: https://github.com/iddqd-park

value: Show HN: Project Echo – A stateless, zero-DB cyberpunk text visualizer


value: akshaysg

value:
Public repositories seem to be getting more AI-generated pull requests, some of which are low-effort and haven’t been manually reviewed.
We built Haystack Slop Detector to scan PRs and flag changes that look like they were made without reviewing them first. We support AI use, but we think it’s important to surface a lack of polish before it becomes a maintainer’s problem.
We'd love feedback, especially from maintainers and people building agentic workflows!

value: Show HN: Haystack Slop Detector – a lightweight barrier against unreviewed PRs

author: akshaysg


value: mr-karan

value:
Hey HN, I'm Karan. I built Logchef because we moved our log workloads to ClickHouse at Zerodha and found the ecosystem lacking for actual log exploration.
Tools like Metabase and Grafana are great for dashboards, but log exploration is a different workflow.
The Grafana ClickHouse plugin requires manual column configuration for logs, has no field sidebar, and its ad-hoc filters are slow on large tables.
Grafana's RBAC is Enterprise-only, and even then it's datasource-level and not at table-level. If someone has access to the ClickHouse datasource, they can query any table. In Logchef, you create Sources (pointing to specific tables) and assign them to Teams. Team A only sees their logs, Team B only theirs. Fine-grained access control without any Enterprise license :)
Metabase has no concept of log-specific features at all. We kept falling back to raw SQL in clickhouse-client, which works but isn't something you want to hand to your whole team.
So I built Logchef — a log viewer designed specifically for ClickHouse. Schema-agnostic, so you can start filtering immediately without migrations.
What it does:
- Point at any ClickHouse table – no schema migrations/no OTEL requirement
- LogchefQL query language (simpler than SQL for filtering)
- Field sidebar like Kibana – click values to add filters
- SQL-based alerting that routes to Alertmanager
- AI assistant that turns natural language queries like "find slow POST requests" into working SQL
- MCP server for querying logs from your favourite LLM assistant tool
- Single Go binary (~15MB), embeds the frontend
We've been running this in production for 8 months and I'm excited to ship v1.0 today.
Demo: https://demo.logchef.app
GitHub: https://github.com/mr-karan/logchef
Docs: https://logchef.app
Happy to answer questions about ClickHouse for logs, the architecture, or anything else.

value: Show HN: Logchef – Open-source schema-agnostic log viewer for ClickHouse

author: mr-karan


value: Xyra

value:
I hardened up a Postgres database enough to give the public access to run arbitrary queries over an interesting and growing dataset.
I've provided a Claude-optimized prompt for driving this search experience. Opus 4.5 is great at writing SQL and taking advantage of our other features.
There's over 23M embeddings (2048*32 bit Voyage-3.5-Lite over ~300 token chunks, 20% overlapped), 600 GB of indexes for performance, a prompt for letting Claude Code w/ Opus 4.5 drive usage, and there's full support for vector algebra. One can actually embed arbitrary concepts like "FTX" and "guilt" vectors and store these embeddings on the server, and refer to them in queries like @FTX + @guilt.
Because you and your agent can write and run 100k character SELECT statements for up to 60s, you can really answer some incredibly nuanced questions very easily now.
I'm doing a startup building subjective judgement infrastructure, HMU if interested in angel investment.

value: Show HN: Explore ArXiv/HN/LessWrong with SQL and Vector Algebra

author: Xyra


value: AlexanderZ

value: Show HN: Brain training game based on Aaronson Oracle

author: AlexanderZ


value: sureshcsdp

value:
Hi HN,
I’m a solo founder and SRE background engineer. I built CleanCloud to solve a problem I kept seeing on teams I worked with: cloud accounts slowly filling up with orphaned, unowned, or inactive resources created by elastic systems and IaC — but nobody wants tools that auto-delete things.
CleanCloud is a small, open-source CLI that:
- Scans AWS and Azure accounts in read-only mode
- Identifies potential “hygiene” issues (unattached EBS volumes, old snapshots, inactive CloudWatch logs, untagged storage, unused Azure public IPs, etc.)
- Uses conservative signals and confidence levels (HIGH / MEDIUM / LOW)
- Never deletes or modifies resources
- Is designed for review-only workflows (SRE-friendly, IaC-aware)
What it intentionally does NOT do:
- No auto-remediation
- No cost optimization / FinOps dashboards
- No agents, no SaaS, no ML
- No recommendations based on a single risky signal
This is early-stage and I’m explicitly looking for feedback from SREs / DevOps folks:
- Are these the right problems to focus on?
- Are the signals conservative enough to be trusted?
- What rules would you actually want next?
Repo (MIT licensed): https://github.com/sureshcsdp/cleancloud
If this looks useful, a  helps a lot. Brutally honest feedback welcome.
Many Thanks
Suresh

value: Show HN: CleanCloud – Read-only cloud hygiene checks for AWS and Azure

author: sureshcsdp


value: smakosh

value: Show HN: Our vibe coded openrouter alternative just made over $40k last 30 days

author: smakosh


value: ada-yang

value: Show HN: Claude Livestreaming NetHack on GitHub Actions

author: ada-yang


value: liteclient

value: Show HN: LiteClient – a local-first bloat-free API client for VS Code

author: liteclient


value: chieund

value:
Hi HN!
I built LLMKit after getting frustrated with choosing the right LLM for different projects. Instead of guessing or relying on benchmarks that don't match real use cases, I wanted to see actual performance with my own prompts.
What it does:
• Compare up to 5 models simultaneously (GPT-4, Claude, Gemini, etc.)
• Real-time streaming comparison - watch models race to respond
• Custom scoring weights based on your priorities (speed vs cost vs quality)
• System prompt support for production-realistic testing
• TTFT (Time to First Token) metrics for latency-sensitive apps
• No signup required, API keys stay in your browser
The "aha moment" was adding streaming comparison - seeing GPT-4 start fast but Claude catch up, or watching cost-effective models perform surprisingly well. It's like A/B testing but for LLMs.
Built with Next.js + TypeScript. The streaming implementation was tricky - had to handle different provider formats (OpenAI vs Anthropic) and parallel SSE connections.

value: Show HN: LLMKit – Compare LLMs side-by-side with real-time streaming

author: chieund


value: grantsingleton

value:
Hi HN. I’m building BrowserForge (https://browserforge.ai), an AI browser agent platform.
It uses the latest and best computer use model, gemini 2.5 computer use. There is no better computer use model right now, and you can try it out free.
Sign up now and get 1000 free credits to try it out.
What BrowserForge does differently is run agents in real Chrome instances and focus on goal-oriented automation. You describe what you want done (as you would to a teammate), and the agent navigates the site like a human would, clicking, typing, selecting dropdowns, waiting for dynamic content, extracting structured data, and completing multi-step flows.
A few things we’re building around:
- Persistent authenticated sessions: log in once, reuse saved cookies/auth state for future runs.
- Monitoring + reliability: agents can retry steps and handle common UI variability (and when something needs human help, that’s surfaced instead of silently failing).
- Integration-ready: trigger runs and receive results via API + webhooks.
Concrete examples people use this for:
- Log into an admin portal, download a daily report, extract key numbers, and forward them to your systems.
- Monitor a marketplace for new listings / price changes / removals and alert when conditions are met.
- Fill out multi-step forms (applications, record updates, ticket creation) inside authenticated SaaS tools.
It’s early, and it won’t work on every site without friction (things like 2FA/CAPTCHAs can require manual intervention), but for a lot of browser-based ops it’s already useful.
I’d love feedback from HN on:
What browser workflow would you automate first?
Where do existing approaches (Playwright/RPA/etc.) break down for you?
What would you want for debugging/auditability when an agent runs?
If you want to try it, it’s here: https://browserforge.ai (CTA: Get Started Free).

value: Show HN: BrowserForge – AI browser agents (1000 free credits)

author: grantsingleton


value: ilikebits

value:
Hey HN, we’re Eliza and Xin. We’re working on Hurry, an open source drop-in tool that adds distributed build caching to Cargo with (almost) zero configuration. Wherever you run cargo build, you can run hurry cargo build instead, and expect around 2-5x (our best benchmark is 22x) faster builds.
We built this because we were dissatisfied with the current build caching options available for Rust. Buck and Bazel require learning a new tool. GitHub Actions and swatinem are too coarse-grained (either the whole cache hits, or none of it does) and finicky to debug, and cargo-chef and Docker layer caching have the same problems.
We wanted something that could restore cache at the package level, did not require integration-specific setup, and worked everywhere.
Hurry is fully open source under Apache 2. You can try it out now with our cloud hosted caching service at https://hurry.build or self-host your own build cache service from https://github.com/attunehq/hurry. Sorry in advance for the rough edges - we have some customers already exercising the hot paths, but build tools are pretty large surfaces. We’ve got a list of known limitations at https://github.com/attunehq/hurry?tab=readme-ov-file#known-l....
We’d love for folks here to try it out (maybe on your next Rust winter side project?) and let us know what you think. We’ll be in the comments here, or you can email us at founders@attunehq.com.
Our goal is to make all parts of software engineering faster. If you have some part of your coding workflow that you want faster, please feel free to reach out. We’d love to chat.

value: Show HN: Hurry – Fast Rust build caching

author: ilikebits


value: hotelsw

value: I’ve been working on a lightweight runtime loader for Cortex-M (and 32-bit ARM more generally) that can load and relocate ELF modules from SD/ flash/ generic storage at runtime. It’s not a dynamic linker in the Linux sense, but it does perform symbol resolution and relocation against a host-defined ABI.<p>The goal is to enable extensible firmware platforms without reflashing or statically linking everything into the main image. I’m sharing it both in case it’s useful to others, and to get constructive feedback.

value: Show HN: TethysRT, a tiny dynamic loader for 32 bit ARM embedded systems

author: hotelsw


value: tchn

value:
Fun With Python and Emoji: What Might Adding Pictures to Text Programming Languages Look Like?
We all mix pictures, emojis and text freely in our communications. So, why not in our code?
Slides, Python notebook available at:
https://github.com/tedconway/pydataboston2025

value: Show HN: What Might Adding Pictures to Text Programming Languages Look Like?

author: tchn


value: JohannesGlaser

value:
I’ve been frustrated by how stateless most LLM assistants still are. Longer context windows and retrieval help with recall, but state usually disappears between sessions.
I ended up building a file-based memory architecture where memory, rules, and state live explicitly outside the model. It’s modular (notes, OCR, training logs, etc.) and I’ve been using it daily for about three months as a general-purpose assistant. It doesn’t require fine-tuning or custom infrastructure — just files and an existing LLM backend.
I’m curious how others here handle long-term state: files, databases, event sourcing, vector layers, or something else?
For context: private, non-commercial use is free.
http://metamemoryworks.com
Architecture + repos linked

value: Show HN: File-based persistent memory for LLM assistants

author: JohannesGlaser


value: twelvechess

value: Here is the repository link: https://github.com/evangelosmeklis/MindfulBoo

value: Show HN: MindfulBoo – open-source mindfulness iOS app

author: twelvechess


value: sanjeed

value: Show HN: ChatGPT Wrapped – Your year with ChatGPT, visualized

author: sanjeed


value: babush

value: Show HN: LLVM-jutsu: Anti-LLM obfuscation pass

author: babush


value: AmbroseBierce

value:
NotSoAAA is a website to find games on Steam with with few -but positive- reviews (by default it shows games with less than 42 reviews but users can select up to 100), so it's a way to give a second chance to games that maybe deserve better! The user can hover any game to watch it's trailer video.
At the beginning the user can filter games by selecting popular games that they like so it tries to find similar ones, or they can just keep scrolling to view all games.
Also worth noting that after scrolling a few games another sections show up that allows the user to filter by tags instead, where the user can select multiple ones, or they can ignore it and keep scrolling to continue viewing games based on existing filters.
Initially I tried scrapping all games from Steam but they throttle such attempts after a few hundreds requests so I kept looking for alternatives and find a really nice dataset on Kaggle so I used that instead, you can find it by `fronkongames/steam-games-dataset`
The site uses vanilla JavaScript, the backend uses PHP for templates and Python for all the scrapping and scripting.
Any feedback or questions are welcomed.
Some more technical insights (AI generated):
- Hybrid filtering pipeline combines JSON-backed datasets with session-level exclusion to keep recommendations fresh per visitor.
- Uses a single reusable <video> element managed by dash.js/Hls.js to minimize memory churn while previewing trailers across many cards.
- Implements dynamic batching plus scroll-throttled infinite loading with server-side session tracking to avoid repeating games between requests.
- Shares filter state between PHP and front-end sliders, including custom review/price ranges that trigger server rebuilds via abortable fetch calls.
- Normalizes scraped Steam data with Python scripts that add derived metadata (tags, similar games, app IDs) and aggressively de-duplicate entries before publishing.
- Generates video compilations by clipping MPD streams via ffmpeg, overlaying game titles, and auto-marking processed entries to prevent reuse.
- Adaptive UX toggles between tag and “similar games” discovery modes, automatically disabling tag filters when curated picks are active.

value: Show HN: Find games with few -but positive- reviews based on games that you like

author: AmbroseBierce


value: verdverm

value: Show HN: Making SVG Sparkline Component with an Agent to Graph Token Usage

author: verdverm


value: Pastaza

value: Show HN: Cardly – a tiny card-first app to capture people's Gift Cards

author: Pastaza


value:
  #!/usr/bin/env python3
  """
  GEOMETRIC DERIVATION OF G & VALIDATION WITH GR

  This script tests the hypothesis that G is a derivative artifact of the
  proton's holographic scaling (i=32).

  Reference Paper: https://doi.org/10.5281/zenodo.17847770
  """

  import math

  # 1. CONSTANTS (CODATA 2022)
  c      = 299792458.0              # m/s
  hbar   = 1.054571817e-34          # J s
  alpha  = 7.2973525643e-3          # Fine-structure
  mp_kg  = 1.67262192595e-27        # Proton mass
  me_kg  = 9.1093837139e-31         # Electron mass
  G_codata = 6.67430e-11            # Empirical G (for validation)

  # Derived Planck Mass (Standard) for consistency check
  mP_std = math.sqrt(hbar * c / G_codata)

  def compute_acceleration(name, mass, topo_n, radius):
      # PHASE 1: DYNAMIC VALIDATION
      # Goal: Recover Schwarzschild metric using geometric projections.

      w = 2.0 # Structural limit

      # Linear Mass projection (Source)
      L_src = (mass * hbar) / (c * mP_std**2)

      # Structural Limit (Horizon) - Equivalent to Schwarzschild radius
      L_lim = w * L_src

      # Electrostatic projection
      if topo_n != 0:
          lambda_e = hbar / (me_kg * c)
          Le = alpha * abs(topo_n) * lambda_e
          L_src += Le

      # The Unified Geometric Metric
      if radius <= L_lim:
          return {"name": name, "stat": "HORIZON", "val": 0, "gr": 0}

      # Hypotenuse form: ai = c^2 * L / (r^2 * sqrt(1 - 2L/r))
      metric_factor = math.sqrt(1.0 - L_lim / radius)
      ai_unified = (c**2 * L_src) / (radius**2 * metric_factor)

      # GR Benchmark (Schwarzschild)
      rs = 2 * G_codata * mass / c**2
      acc_newton = (G_codata * mass) / (radius**2)
      acc_coulomb = 0.0
      if topo_n != 0:
          acc_coulomb = (8.98755e9 * 1.60217e-19**2) / (radius**2 * me_kg)

      if radius <= rs:
          ai_gr = float('inf')
      else:
          ai_gr = (acc_newton / math.sqrt(1.0 - rs/radius)) + acc_coulomb

      return {"name": name, "stat": "OK", "val": ai_unified, "gr": ai_gr}

  def derive_closed_G():
      # PHASE 2: HOLOGRAPHIC DERIVATION
      # Hypothesis: mp scales from mP at i=32 (4^32 surface scaling)
      # mp = (sqrt(2) * mP / 4^32) * (1 + alpha/3)

      geometry = math.sqrt(2) * (1 + alpha/3)
      mP_geo = (mp_kg * 4**32) / geometry

      # G = hbar * c / mP^2
      return (hbar * c) / (mP_geo**2)

  # EXECUTION
  objects = [
      {"n": "Electron",     "m": me_kg,   "q": 1, "r": 1e-10},
      {"n": "Proton",       "m": mp_kg,   "q": 1, "r": 1e-10},
      {"n": "Earth",        "m": 5.972e24, "q": 0, "r": 6.371e6},
      {"n": "Sun",          "m": 1.989e30, "q": 0, "r": 6.963e8},
      {"n": "Neutron Star", "m": 4.14e30,  "q": 0, "r": 12000},
      {"n": "Sgr A* (Lim)", "m": 8.26e36,  "q": 0, "r": 1.23e10}
  ]

  print(f"{'OBJECT':<12}| {'UNIFIED':<18}| {'GR':<18}| {'DIFF %'}")
  print("-" * 65)

  for obj in objects:
      res = compute_acceleration(obj['n'], obj['m'], obj['q'], obj['r'])
      if res['stat'] == 'HORIZON':
          print(f"{res['name']:<12}| {'SATURATION':<18}| {'HORIZON':<18}| {'MATCH'}")
      else:
          diff = abs(res['val'] - res['gr']) / res['gr'] * 100
          if diff < 1e-9: diff = 0.0
          # Formatting with .5e to verify consistency
          print(f"{res['name']:<12}| {res['val']:<18.5e}| {res['gr']:<18.5e}| {diff:.8f}")

  print("-" * 65)
  print("\nPHASE 2: G DERIVATION")
  G_calc = derive_closed_G()
  disc = abs(G_calc - G_codata) / G_codata * 1e6
  print(f"Formula:   G = (hbar * c * 2 * (1 + alpha/3)^2) / (mp^2 * 4^64)")
  print(f"Derived G: {G_calc:.11e}")
  print(f"CODATA G:  {G_codata:.11e}")
  print(f"Diff:      {disc:.2f} ppm (within 22 ppm uncertainty)")

title: Show HN: G=(hbar*c*2*(1+alpha/3)^2)/(m_p^2*4^64) ≈ 6.6742439706e-11 (8 ppm)


value: mnorth

value: Show HN: I want to fix Durable Execution

author: mnorth


value: MCP servers are great, but they can be limited by the context length of the model you're using.<p>withcodemode lets you compress all the tools available on a remote MCP server into a single tool, and then use a code generation agent to achieve the user's goal.

value: Show HN: withcodemode – Proxy any Remote MCP server to run under codemode


value: claygood

value: Show HN: A persistent fact store for AI world simulations

author: claygood


value: thebbapp

value:
In the age of blogging, WordPress made it easy to put up a site and post. Many years later, nothing quite like it came for apps.
I made the BbApp framework to let you skip months of pain on the repetitive parts of building a very expensive app for WordPress.
It includes an XCode project template and dozens of frameworks to tie them together ready for review by the app store.
You can use BbApp with WordPress alone or BBPress. To enjoy a fully-featured native app just download, build in XCode, and publish.
It also includes open-source PHP libraries that make it easy to integrate your existing native mobile application with WordPress.
Features
- Instant post loading
- Guest push alerts for new posts and comments
- Infinite scroll
- Guest posts + comments (BBPress only)
- Guest comments (WordPress and BBPress)
- Multiple post categories (WordPress only)
- Offline mode
- Mark read/unread
- Dark mode
- Deep links
- "Install" website app banner
Platforms
- iPhone, iPad (iOS)
- Macbook, Mac Mini, iMac (macOS)
- Apple TV (tvOS)
- Android (planned)
What's included
- XCode template project
- 40+ Swift 6 and @Observable XCode Frameworks with API documentation
- Plugin for WordPress (PHP 7.2.24+)
- 20+ lightweight and modular PHP Libraries

value: Show HN: Native Mobile App Framework for WordPress – BbApp

author: thebbapp


value: zipqt

value: Show HN: Corli – an RPG-style productivity app for building real habits

author: zipqt


value: skicoachapp

value:
Hi HN,
I’m a solo developer from Austria. After 18 months, I built SkiCoach - an AI ski coaching app based on a simple philosophy: your data is yours.
The Black Box Concept:
Like an airplane black box, the app records everything - GPS, accelerometer, gyroscope, barometer - but nothing ever leaves your device. No cloud sync. No accounts. No tracking. Full AI processing happens on-device.
What it does:
 ∙ Analyzes ski technique via phone sensors (phone stays in pocket)
 ∙ Real-time audio coaching while skiing
 ∙ Technique score 0-100 per run
 ∙ Auto-detects when you start skiing (>10km/h + altitude >1000m)
 ∙ Works completely offline (no signal needed on mountain)
Tech:
 ∙ Flutter (iOS + Android)
 ∙ TensorFlow Lite for on-device AI
 ∙ 4 languages (EN/DE/FR/IT)
Business model:
One-time €19.99 purchase. No subscription. I believe ski apps shouldn’t cost €25/year forever.
More on the philosophy: theskiblackbox.com
Live on iOS, Android this week: skicoach.app
Would love feedback from skiers and privacy-focused folks.

value: Show HN: The SkiBlackBox–100% offline AI ski coach, zero data leaves your phone

author: skicoachapp


value: Song-JunHyeong

value:
Hi HN,
I’m the creator of LTP (Lazy Tool Protocol). I built this because I was frustrated with the hidden costs of building AI agents with many tools.
The current standard for tool-calling (like MCP) often requires loading every tool's full JSON schema into the AI's context at the start of a session. If you have dozens or hundreds of tools, you’re burning through tens of thousands of tokens before the agent even says "Hello."
LTP changes this by introducing a "Lazy Loading" pattern.
Instead of bloating the context, LTP uses a CLI-based bridge. The AI agent only fetches the specific tool definitions it needs, when it needs them.
What makes LTP 0.1.0 different:
Up to 93% Token Savings: In my latest benchmarks, LTP reduced token overhead from 300,000 to just 20,000 for a 100-call session.
The --schema Flag: By providing compact function signatures once at the start, the AI can understand hundreds of tools with minimal overhead, eliminating the need for repeated metadata calls.
Executable "Crafts": We’re moving beyond simple prompts. A "Craft" is a reusable package that combines precise AI instructions (CRAFT.md) with executable automation scripts (execute.ts). It’s like a library of expert skills for your AI.
Security-First: I know running local commands is a concern. LTP includes built-in whitelisting, sandbox path restrictions, and mandatory confirmation for dangerous operations like file deletions.
How it works: You give your AI a simple system prompt (provided in the repo) that teaches it to use the ltp CLI. The AI then uses ltp list --schema to see what’s available and ltp call to execute tools.
I'm currently running this on my VPS and using it for my own daily workflows.
Repo: https://github.com/JuN-B-official/ltp
Url: https://ltp.jun-b.com
Efficiency Analysis: https://ltp.jun-b.com/docs/effect
I’d love to get your feedback on the architecture and the efficiency of this approach!

value: Show HN: LTP – Lazy Tool Protocol. Up to 93% token reduction for AI agents

author: Song-JunHyeong


value: noldai

value:
SpecFact CLI helps teams modernize legacy Python codebases by reverse engineering undocumented code into executable contracts with runtime enforcement.
What it does:
- AST-based analysis extracts functions, classes, dependencies from legacy code
- Generates runtime contracts (icontract + beartype) that prevent regressions
- Symbolic execution (CrossHair) finds edge cases that LLMs miss
- CI/CD integration blocks breaking changes automatically
Why brownfield-first:
- Works with undocumented code, no type hints required
- Designed for legacy modernization, not adapted from greenfield
- CLI-first: works offline, no account, zero vendor lock-in
Current status:
- Contract extraction and runtime enforcement (production-ready)
- Sidecar validation in research phase: We're investigating how to run CrossHair against unmodified codebases without requiring decorators in source. This will enable symbolic execution on third-party/legacy code without editing files. See https://github.com/nold-ai/specfact-cli/issues/57 for progress.
Quick start:

    # Install slash commands (recommended for AI IDEs)
    specfact init --ide cursor

    # Then use in your AI IDE:
    /specfact.01-import --repo .

Or CLI-only mode:

    uvx specfact-cli@latest import from-code legacy-api --repo .
    specfact analyze contracts --bundle legacy-api
    specfact enforce sdd --sdd .specfact/sdd.yaml

Built for teams modernizing legacy Python systems in finance, healthcare, and data engineering where bugs cost millions.
Links:
- GitHub: https://github.com/nold-ai/specfact-cli
- Documentation: https://specfact.io
- Blog: https://specfact.dev/blog (technical deep-dives)
What we're looking for:
- Feedback on brownfield use cases
- Integration examples (VS Code, Cursor, GitHub Actions)
- Real-world case studies
I've been using it on my own legacy codebase and caught 4 bugs that would have shipped. Happy to answer questions!

value: Show HN: SpecFact CLI: Reverse Engineer Legacy Python into Enforceable Contracts

author: noldai


value: williamolsen

value:
Hey HN, we built Tpylo over the past few months and would love your feedback.
The backstory is pretty simple. Creators are juggling too many platforms just to make a living. Patreon for memberships, Ko-fi for tips, Discord for community, Gumroad for selling stuff, and the list goes on. We thought there had to be a better way.
So we built something that brings it all together. One profile page where creators can accept donations, sell monthly memberships, chat with supporters in real time, and run a digital store for ebooks or courses or whatever they make. The supporter pays, money goes straight to the creator's connected account, we take a small platform fee, done.
We went with direct charges instead of holding funds. Seemed cleaner and less regulatory headache. Real-time chat runs on WebSockets so creators can talk with paying members without sending them elsewhere.
Would appreciate if you could check it out and share your thoughts. What features would make this actually useful for you as a creator or supporter?

value: Show HN: Tpylo All-in-one creator support platform

author: williamolsen


value: I built a simple TUI-based metronome for practicing guitar. I wanted something keyboard-driven, simple to use, and aesthetic that I could run directly in my IDE terminal. Most existing terminal options felt either too minimal, overcomplicated, or unmaintained, so I put this together in a day over the weekend for my own use. A colleague encouraged me to share it on GitHub.<p>Feedback welcome.

value: Show HN: A small terminal metronome written in Go


value:
Hey all,
Training AI Models to reason is currently very expensive. You require a lot of data, tons of compute in Reinforcement Learning, and more. And the reasoning infrastructure is not reusable.
On top of all this, we don't really have a way to improve targeted performance and personalize intelligence within the systems.
Over the last year, I've been looking into latent space reasoning as a way to solve this. By doing this, we can create a different reasoning layer that is reusable across models. We created a simple layer for 50 cents, and it already improves performance. We're working with a few people across major AI Labs at exploring this, but I also wanted to open source because intelligence deserves to be open. To that end, our startup has even opened up a small monthly prize pool for top contributors to the repo.
Would love to have you in there. Here is a report we did breaking down the core design philosophy here-- https://www.artificialintelligencemadesimple.com/p/how-to-te...

value: Show HN: A repo to turn any model into a reasoning model without training


value: Just a lite Jira, in case you want to use something else.

value: Show HN: A simple, free ticket/issue tracker for team collaborations


value: Well, we all had a good or a bad day, have you ever questioning how the rest of the world doing today? Now let's log it and find out.

value: Show HN: Womoo – World Mood Logger

title: Show HN: Womoo – World Mood Logger


value: admtal

value: Show HN: Pac-Man with Portals

author: admtal

title: Show HN: Pac-Man with Portals


value:
I built a drag-and-drop map playground to compare the true sizes of countries and visualize Mercator distortion, just for fun and sharing. Open source + easy to replace the GeoJSON with your own data.
Demo: https://www.runcell.dev/tool/true-size-map
Source: https://github.com/ObservedObserver/world-map-reality

value: Show HN: Drag-and-drop playground to compare the true sizes of countries


value: EncoreVlaced

value: Show HN: Lumina – a minimal AI reflection app (source code)

author: EncoreVlaced


value: Show HN: StringTune-3D – Control Three.js scenes via CSS variables


value: solosquad

value: Show HN: AI Financial Advisor App, Get You Plan for Free

author: solosquad


value:
Hey HN,

  After burning through dozens of credits rephrasing the same prompt in different AI image tools, I built gpt2image.io - a conversational interface for GPT Image 1.5.

  **The core idea:**
  Instead of prompt archaeology ("was it 'modern minimalist' or 'contemporary minimal' that worked?"), you iterate through dialogue:
  - "Change the background to midnight blue"
  - "Make the text bolder"
  - "Keep everything but replace the laptop"

  Context persists across turns. Style consistency is maintained. It's how humans actually work.

  **Built for:**
  - Developers mocking up UIs
  - Designers exploring concepts rapidly
  - Product teams creating marketing assets
  - Anyone who needs images that evolve with ideas

  **Tech highlights:**
  - Built on Next.js 16 + React 19 (using React Compiler for optimization)
  - Turbopack for stupid-fast local dev
  - Multi-language support out of the box
  - Clean API for integrations

  **What it's not:**
  - Not trying to replace Photoshop
  - Not a magic solution for everything
  - Still bound by underlying model capabilities

  Try it: https://www.gpt2image.io (first 2 images free)

  Looking for feedback on:
  - What editing patterns break down
  - What controls matter most in production workflows
  - API features you'd actually use

  Contact: contact@gpt2image.io

value: Show HN: A GPT Image 1.5 UI for developers tired of rewriting prompts


value: HoloSecNerd

value:
I got tired of the OS scanning my local files. I wanted a directory that was mathematically invisible to the system.
This is a Python-native, air-gapped encryption tool. It runs locally. No APIs. No subscriptions. It just orphans the file, locks the door, and throws you the key.
I built it for myself. If you want the silence, it's yours.

value: Show HN: I built a Python-native vault because I don't trust the cloud

author: HoloSecNerd


value: nsomani

value: Show HN: Do Models Represent Epistemic Stance?

author: nsomani


value: foolmarshal

value:
Hi HN,
Day 3 of building eze, an AI co‑pilot that turns raw startup ideas into execution roadmaps.
What’s happened since the last update
- Early trust: More than 10 people have joined the waitlist for early access and early‑bird benefits. Still tiny, but it’s enough signal that the problem and framing resonate.
- Canvas revamp: Rebuilt the roadmap canvas from basic boxes-and-arrows into a more interactive workspace. Stages are visually separated, nodes are cleaner, and it’s much easier to see your current position in the journey.
- Chat UX upgrade: Improved the chat interface so it feels like a focused founder workspace—clearer prompts, better typography and spacing, and less “generic chat window” energy.
- Pain validated by another builder: A fellow Indie Hacker described their current setup as a pile of long ChatGPT threads + bookmarks where CTRL‑F barely helps because everything is split across many conversations. They want “one product to bring order to all the steps with an easy way to search and navigate.” That’s exactly the chaos eze is meant to clean up.
- Towards credible guidance, not fluff: I’ve started collecting authorized, high‑signal sources on how experienced founders actually build companies—YouTube transcripts, articles, blogs, and summaries/notes from classic startup books. The idea is to ground eze’s roadmaps and suggestions in real founder behaviour and robust frameworks, instead of generic, feel‑good LLM advice.
The north star stays the same: remove one big variable in the founder journey — “what should I do next, and in what order?” — so more people can move from idea to launch with a realistic, personalized plan.
If you’d like to follow along or get early access once v1 is ready:
https://eze.lovable.app/
Feedback, skepticism, and “this will fail unless you solve X” comments are very welcome.
Day 1 - https://news.ycombinator.com/item?id=46341465
Day 2 - https://news.ycombinator.com/item?id=46350827

value: Show HN: Eze – AI startup roadmap co‑pilot (Day 3 update)

author: foolmarshal


value: selenehyun

value: Hi HN,<p>Lynq is a Kubernetes operator I have been building as a personal project, and this post introduces a dashboard I built along the way.

value: Show HN: A dashboard for understanding Kubernetes operators

author: selenehyun


value: minimk

value:
Hi HN — I made a small browser tool that adds a subtle, natural-looking smile to portrait photos.
Why: I often needed a quick “smile version” for profile pics and headshots without manually retouching.
How it works: upload a photo → choose a smile style/strength → generate → download.
Limits: best results with a clear, front-facing face; strong side angles or heavy occlusion can look off.
I’d love feedback on realism (teeth/cheeks/eyes), and any failure cases you notice.

value: Show HN: A smile filter that adds a natural-looking smile

author: minimk


value: shinymonitor

value:
I wrote a protocol and C implementation for communication in "zero-infrastructure" and high-adversity environments.
EFPIX (Encrypted Flood Protocol for Information eXchange) is a topology-agnostic flood-type relay protocol that also achieves end-to-end encryption, plausible deniability for users, untraceability of messages, spam resistance and other optional features. It is designed for environments where you cannot trust the network topology or network participants. Unlike Tor or I2P, it doesn't rely on stable circuits or central directories.
Use cases:
- Space, research, military, or other remote networks where the existence and maintenance of a server is not feasible
- Disaster zones where network infrastructure was lost
- Authoritarian Regimes for whistleblowing, journalism and activism where communication is surveilled and censored
- Broadcasts like emergency rescue calls, disaster warnings, and news distribution
I have written a whitepaper (use case + motivation, encoding + decoding algorithm, optional enchancements, threat analysis, comparison with other protocols, etc.). I am looking for feedback.
AMA.
Whitepaper: https://arxiv.org/abs/2509.08248
Implementation: https://github.com/shinymonitor/libefpix
Blog: https://shinymonitor.github.io/projects.html

value: Show HN: Efpix – A flood protocol with E2EE and metadata protection

author: shinymonitor


value: Show HN: Running Arch Linux on a $50 Smartwatch (Spreadtrum SC9832E)


value: Show HN: I built a parser to use Singapore QRs with Wise/my home bank


value:
Hi,
I wanted to create an AI powered team, where agents with different skills and tools could collaborate with each other on complex tasks.
But the current solutions felt too developer oriented. I wanted something that felt closer to how humans actually work. So I decided to create Starships.ai, where working with agents feels like talking to a remote employee on Slack.
The goal is to create an organization that is primarily run by agents, with humans reviewing critical decisions.
I would love to hear what you think, and would love for you to give it a try.
Thanks
https://starships.ai

value: Show HN: Starships.ai – Build, deploy and orchestrate an AI agent team


value:
Hi HN
I built CineCLI — a cross-platform terminal app to browse movies, view details,
and open torrents directly in your system torrent client.
Features:
- Search movies from the terminal
- Rich UI with ratings, runtime, genres
- Interactive & non-interactive modes
- Magnet handling via system default client
- Linux/macOS/Windows support
- No ads, no tracking
GitHub: https://github.com/eyeblech/cinecli
PyPI: https://pypi.org/project/cinecli/
Would love feedback from terminal + Python folks

value: Show HN: CineCLI – Browse and torrent movies directly from your terminal


value: Show HN: Nønos – a zero-state OS that runs in RAM


value: GrammarChecker

value:
Most AI-written text isn’t obviously wrong.
Grammar is fine. Facts are usually fine.
What gives it away is the tone.
We kept seeing the same patterns: sentences with identical rhythm, over-explained transitions, and a kind of “smoothness” that doesn’t match how people actually write. AI detectors try to flag these patterns, but chasing detectors felt like treating the symptom, not the cause.
So we built a small AI Humanizer that works at the sentence level. Instead of masking signals or applying prompt tricks, it rewrites text to improve flow, vary structure, and reduce repetition — aiming for writing that simply reads more naturally.
The tool doesn’t try to guarantee that text will pass any specific detector. Different detectors behave differently, and that changes all the time. Our goal was narrower: make AI-assisted writing feel intentional and human-readable again.
This started as an internal experiment while working on AI detection, and we decided to make it public to see how others approach the same problem.
Link: https://dechecker.ai/ai-humanizer
Would love feedback, especially from people who write a lot with AI or build NLP tools.

value: Show HN: We built an AI Humanizer to fix unnatural AI writing

author: GrammarChecker


value: mootoday

value: Show HN: A vibe-coded database GUI

author: mootoday

title: Show HN: A vibe-coded database GUI


value: johnj-hn

value:
Hello, all. Luxury Yacht is a desktop app for managing Kubernetes clusters that I've been working on for the past few months. It's available for macOS, Windows, and Linux. It's built with Wails v2 (https://wails.io), so huge thanks to Lea Anthony for that awesome project. Can't wait for Wails v3.
This originally started as a personal project that I didn't intend to release. I know there are a number of other good apps in this space, but none of them work quite the way I want them to, so I decided to build one. Along the way it got good enough that I thought others might enjoy using it.
Luxury Yacht is FOSS, and I have no intention of ever charging money for it. It's been a labor of love, a great learning opportunity, and an attempt to try to give something back to the FOSS community that has given me so much.
A word of caution, in case you care about this sort of thing -- I wrote this with AI assistance. I am, first and foremost, a platform/infrastructure engineer, not a software developer. I've learned enough via tinkering and osmosis over the years to have a decent idea of how to write software, but it's not my main gig. I did my best to try to make sure the code isn't garbage, but you might look at it and disagree. I have no doubt that there's a lot of room for improvement, but it works, I think it has a pretty good feature set, and I'll keep iterating on it to make it better.
If you want to get a sense of what it can do without downloading and installing it, read the primer:
https://github.com/luxury-yacht/app/blob/main/docs/primer.md
Or, head to the Releases page to download the latest release:
https://github.com/luxury-yacht/app/releases
Oh, a quick note about the name. I wanted something that was fun and invoked the nautical theme of Kubernetes, but I didn't want yet another "K" name. A conversation with a friend led me to the name "Luxury Yacht", and I warmed up to it pretty quickly. It's goofy but I like it. Plus, it has a Monty Python connection, which makes me happy.

value: Show HN: Luxury Yacht, a Kubernetes management app

author: johnj-hn


value: ivanvolt

value:
Hi HN,
I’m the maker of Aluo.
It’s an AI product photo and ecommerce image editor.
Recently I’ve been doing a major rebuild of the product.
Some features are still being refined, but the core workflows for product images are already usable.
I’m sharing it here to get early feedback and learn from the community.
Happy to answer any questions.

value: Show HN: Aluo – AI product photo and ecommerce image editor

author: ivanvolt


value: sooryagangaraj

value: Show HN: VideoToScreenshots – Auto-extract sharp frames from videos

author: sooryagangaraj


value:
Over the past couple of months, I've been working on gonc. It started as a cross-platform netcat alternative written in Go, but I realized it would be much more powerful with a -p2p flag to automatically punch through NATs and firewalls.
It is now working smoothly. To establish a P2P netcat-like chat connection, you simply run the same command on both sides:
gonc -p2p <passphrase>
Building on this, I implemented a dual (bidirectional) reverse proxy. This allows both peers to access each other's networks simultaneously.
Peer A:
gonc -p2p <passphrase> -linkagent
Peer B:
gonc -p2p <passphrase> -link 1080;1080
This opens port 1080 on both ends as a SOCKS5 & HTTP proxy to tunnel traffic to the other side.
How it differs from frp/rathole: Unlike existing solutions that require you to deploy a self-hosted Rendezvous/Signaling Server, gonc uses public STUN and MQTT servers for signaling.
For cases involving Symmetric NATs where a relay is unavoidable, gonc doesn't need a proprietary relay server—it can simply use any standard SOCKS5 server as a relay.
Peer B: (only one side needs to specify -x)
gonc -x socks5ip:port -p2p <passphrase> -link 1080;1080
I'd love to hear your feedback or suggestions!

value: Show HN: Gonc – Serverless P2P dual reverse proxy with NAT traversal


value: kuzej

value:
Hi HN,
I built svgtowebp.org, a small “SVG to WebP” converter for the moments when you just want a quick, predictable export without uploading files.
The problem I kept running into was simple: I often get a folder of Scalable Vector Graphics (SVG) from designers, but the place I need to ship them wants a raster image, and WebP is a good format when you care about smaller files.
What this does:
- Convert SVG → WebP for a single file or a whole batch (drag and drop multiple files, then one click converts the whole queue).
- Control output settings: width, height, fit mode, quality, lossless toggle, background (including transparency), and DPI.
- Preview output and compare file sizes, then download individual results or “Download All” as a zip.
Privacy and speed:
Everything runs locally in your browser (no uploads), so your files never leave your device.
I would love feedback on edge cases (fonts, filters, very large SVGs), and on which settings you would want next.

value: Show HN: SVG to WebP – bulk conversion that runs locally in the browser

author: kuzej


value: uSayhi

value: Show HN: ASCII Canvas for AI Context

author: uSayhi

title: Show HN: ASCII Canvas for AI Context


value: brinedew

value:
I made a web game inspired by Geoguessr and Wordle, where you get shown a 3D model of a random human protein each day, and you have to triangulate its gene name using similarity clues.
My background is in wet lab molecular biology and I intend this game to be engaging mostly to other biologists. But if you're outside the field, I'm interested to know if you can still solve it with browser use LLMs, and if you learned something interesting doing so. Let me know what you think.
I made it with Claude over the last 2 months. My coding experience is limited to basic python data analysis and figure making. I've seen people online asking, "Now that we have coding AI, why isn't there a deluge of awesome AI-generated apps made by non-coders?" - if this sounds like you, check out Geneguessr to understand what a web app by a non-coder looks like.
I might write more about the process if there's a demand, but what really unlocked the project for Claude was Linear MCP, where it could put each individual issue on a shared Kanban board. This, and Playwright MCP for testing on live site, were the two workhorses that got me through this. For bugs Claude couldn't one-shot, Linear was great for consolidating issue information so that I could dump it into ChatGPT Codex - it would usually think for like half an hour, output very confusing explanations, but the bug was gone.
Game is free, no log-in required, sorry if you run into any mobile bugs - didn't test it much there.
https://geneguessr.brinedew.bio/

value: Show HN: GeneGuessr – a daily biology web puzzle

author: brinedew


value: zfoong

value:
Happy to announce that we have just launched White Collar Agent — an open-source general computer-use AI agent that helps you automate computer-based tasks with a TUI interface (https://github.com/zfoong/WhiteCollarAgent).
The agent can autonomously interpret your instructions, plan actions, and execute tasks to achieve a wide range of automation goals. The code also serves as a foundation for building your own AI agents. It can perform web tasks and automate OS operations like high-volume repetitive work and batch processing.
Want to translate a whole directory of documents into Japanese? Organize a messy folder of files based on what is inside each file? Scan a folder of images and auto-generate captions for each one? These are tasks that can be easily automated by White Collar Agent.
P.S. You are free to use, host, and even monetize White Collar Agent. If you are an AI engineer or builder, there is a custom agent layer that lets you create a specialized agent you can host. All you have to do is inject the agent’s identity and custom tools.
The GUI mode is still in the experimental phase. If you have any experience developing a GUI agent, we invite you to work together (please reach out to us!).

value: Show HN: White Collar Agent = a computer-use AI agent with TUI interface

author: zfoong


value: danilofiumi

value:
A couple of weeks ago I was listening to a conversation with Elon Musk where he mentioned something that stuck with me.
At Tesla, they don’t run every possible simulation. They focus on the ones that produce real signal.
The branches that generate learning. The boring ones get pruned because they teach nothing.
That idea kept rattling around in my head.
If we take the simulation hypothesis seriously (as he does), maybe the same applies more broadly: only timelines that produce learning are worth exploring. The ones where people take clear positions, make bold calls, and are willing to be wrong in public.
I built YourPrediction as a small experiment in that direction.
It’s a simple platform where people publish concrete predictions (for example, end-of-year takes), and then we track what actually happens over time.
There’s no algorithmic feed optimization or engagement tricks here, just predictions, outcomes, and discussion around why things played out the way they did.
At a minimum, it’s a tool to help us learn faster.
At best, maybe it nudges us toward more interesting intellectual branches.
Happy to answer questions and iterate based on your thoughts.

value: Show HN: A place to make predictions that are worth surviving in the simulation

author: danilofiumi


value: nikhonit

value:
I built this because I consume a lot of technical lectures and long-form podcasts on YouTube, but I found myself wasting hours scrubbing through videos just to find specific citations or concepts.
Recapio is a tool that extracts the transcript and generates structured summaries for videos (and web articles). It’s not trying to replace watching content, but rather to act as a 'Ctrl+F' for video context.
One technical challenge I faced: Dealing with auto-generated YouTube captions vs. forced captions was messy. I had to build a parser that normalizes the timestamps so that when you click a summary point, it actually seeks to the correct frame, even if the caption timing is drifting.
It has a free tier that should cover most casual usage. I’d love your feedback on the extraction quality

value: Show HN: I built a tool to clear my YouTube's "Watch Later" Video Graveyard

author: nikhonit


value: jackculpan

value: Show HN: Claude Code Skills Playground

author: jackculpan

title: Show HN: Claude Code Skills Playground


value: morozred

value:
Hi HN,
A few months ago I posted JotChain here — a work log tool that tried to do too much. The feedback was fair: the value wasn’t obvious.
I rebuilt it with a much narrower focus: performance reviews.
The problem
We recently started doing performance reviews, and I had to review three developers. I remembered some highlights and issues from the past year, but a lot of context was missing — especially small but important things like soft-skill feedback or moments where someone quietly helped unblock the team.
Those things never make it into a 1:1 doc, and by review time they’re gone.
I wanted one place where I could quickly jot things down as they happen, without worrying about structure — and only structure it when it matters.
The approach
Write short notes as work happens (30 seconds, no format)
Add light context (project, teammates)
Pick a date range and generate a clean: self-review, peer/person review, accomplishments summary.
No meeting recordings, no standup bots — just a lightweight log that turns into review-ready output.
It’s early and adoption is slow, so I’m mainly looking for feedback:
- Does this solve a real problem for you?
- How do you handle performance reviews today?
- Is “performance reviews” a strong enough wedge?
Live here: https://jotchain.com
Happy to answer questions and very open to criticism.

value: Show HN: A tiny work log that generates performance review summaries

author: morozred


value: SwiftedMind

value:
Hey,
A few weeks ago I randomly decided to build a seamless pattern engine for Swift/SwiftUI projects. I called it Tessera (GitHub link). It’s an open-source framework that lets you generate endlessly repeatable, seam-free patterns from pretty much anything you can build in code: shapes, SF Symbols, emojis, text, custom icons, etc.
While working on it, I also built a demo app so developers could see how to use the framework. However, that demo turned out to be so much fun to play with that I decided to turn it into a full app.
## Introducing Tessera Designer
Tessera Designer is a Mac app that wraps my Tessera engine in a UI that anyone can use. It comes with lots of symbols you can customize, and you can also add text, emojis, or your own images. The app then lays everything out to fill your canvas with a pattern.
There are 2 modes available:
Tile mode lets you design a single tile (a small square) that can be repeated endlessly without visible seams. Exporting gives you a small image you can use anywhere.
Canvas mode lets you create an export of a fixed size (great for wallpapers, postcards, etc.). In this mode, you can pin images/text to specific positions, and the app fills the remaining space with a pattern, so that they "flow" around your pinned elements.
You can then export tiles or canvases as PNG or as vector-based PDF (so it scales cleanly, as long as the elements you used are vector-based too).
## Roadmap
I’m actively working on new updates. For example, the next version will add a new placement mode for grid-based patterns, and I’m also working on bringing the app to iPadOS and iOS in the near future.
## AI Disclosure
The app itself does not use AI to generate anything. It's based on "traditional" algorithms that can generate these patterns.
However, I am using OpenAI's Codex CLI to collaboratively build this app. While I let Codex write most of the code, I am still deeply involved in and knowledgable about the code it produces. I am a professional software engineer, and coding is a passion of mine. I still make sure the code is clean, correct and well structured. I spend a lot of time refactoring, organizing and verifying the code. I still do most of the thinking and decisions on "how" I want a feature to be implemented, I just let Codex do the typing part that slows me down.
This is the first project I have worked on that is mostly written by AI. It's an experiment. I wanted to see how much faster I could build something I imagined. Traditionally, an app like this would have taken me much much longer to develop.
And I do believe the app is nicely built and well structured. I put a lot of care into making the user interface as well as the user experience as best as I can. This is also the first time I've worked on an app for the Mac, so it's a new experience for me as well.

value: Show HN: Tessera Designer – Generate beautiful, seamless patterns

author: SwiftedMind


value: douglaswlance

value:
I built *CCQL*, a CLI tool that lets you run SQL queries directly against your Claude Code data (history, transcripts, prompts, sessions, etc.).
If you use Claude Code regularly, you quickly accumulate a large amount of interaction data. CCQL makes that data queryable with SQL so you can analyze how you actually use the agent.
*Examples*
```bash
# What tools does Claude use most?
ccql "SELECT tool_name, COUNT(<i>) AS uses
      FROM transcripts
      GROUP BY tool_name
      ORDER BY uses DESC
      LIMIT 10"<p># Find prompts mentioning a topic
ccql "SELECT display, timestamp
      FROM history
      WHERE display LIKE '%authentication%'"<p># Cross-session analysis
ccql "SELECT _session_id, COUNT(</i>)
      FROM transcripts
      GROUP BY _session_id"
```
*Built-in commands*
```bash
ccql prompts --session ses_123
ccql duplicates --threshold 0.8
ccql search "error"
```
*Interesting technical bit*
Claude Code stores its data in a structured local format. CCQL loads that data into an embedded SQL engine (GlueSQL) with a clean, read-first model, so you can safely explore usage patterns without mutating anything.
*Features*
* SQL queries across history, transcripts, prompts, sessions, and todos
* Fuzzy duplicate detection (find repeated or near-duplicate prompts)
* Full-text search with regex
* Safe writes with automatic backups
* Output formats: table, JSON, JSONL
*Install*
```bash
# macOS
brew install douglance/tap/ccql<p># npm (any platform)
npx @douglance/ccql "SELECT * FROM history LIMIT 10"<p># Cargo
cargo install ccql
```
Built in Rust using GlueSQL. MIT licensed.
GitHub: [https://github.com/douglance/ccql](https://github.com/douglance/ccql)
I’ve been using this to understand my own Claude usage patterns—what prompts I repeat, which tools get called most, and how conversations evolve across sessions. Curious what queries others would find useful.

value: Show HN: CCQL – SQL Queries for Claude Code

author: douglaswlance


value: Show HN: AI Gateways the Infrastructure Layer


value: Show HN: Tool to preview mechanical keyboard key sounds


value: giuliomagnifico

value: Show HN: Auto re-post from any HN user to any Mastodon istance (using n8n)

author: giuliomagnifico


value: amarble

value: Show HN: Gen AI Writing Showdown

author: amarble

title: Show HN: Gen AI Writing Showdown


value:
Healthy Base automates PostgreSQL backups so you never have to worry about cron jobs failing silently or lost data.
Features:
- Automated scheduled backups (or manual with one click)
- Encrypted cloud storage with versioning
- Email alerts for backup status and errors
- Mount backups to inspect data without full restore
- Free tier available with 3 backups per project
Stop babysitting pg_dump scripts. Start sleeping easy.

value: Show HN: Automated PostgreSQL backups that verify they work


value: anandvashishtha

value:
Hey HN,
I built KaggleIngest to solve a problem I kept hitting: using AI coding assistants effectively during Kaggle competitions.
The problem: You want Claude/Copilot to help you iterate on a Kaggle competition, but feeding it useful context is painful. There are hundreds of notebooks, limited context windows, and valuable insights are buried in noise.
The solution: KaggleIngest takes any Kaggle competition or dataset URL and outputs a token-optimized file containing:
Top-ranked notebooks (scored by upvotes × recency)
Key code patterns (imports and visualizations stripped)
Dataset schemas parsed from CSVs
Competition metadata
Demo: http://kaggleingest.com/
GitHub: https://github.com/Anand-0037/KaggleIngest
Stack: FastAPI, React 19, Redis, Python 3.13
The output uses TOON (Token-Optimized Object Notation) which reduces token usage by ~40% compared to standard JSON.
I'd love feedback on the approach or feature requests. Thanks for looking!

value: Show HN: KaggleIngest –Provide Kaggle competition context to AI coding assistant

author: anandvashishtha


value:
Hey HN, I built this because I was frustrated re-explaining my setup every Claude Code session and hitting context limits faster than needed.

  The plugin uses mem0.ai to:

  - Automatically retrieve relevant memories before each prompt (UserPromptSubmit hook)
  - Store conversation context when sessions end (Stop hook)
  - Semantic vector search so only relevant context is injected

  Example: Claude now knows I prefer Python, my tech stack, and project context - without me repeating it.

  Technical details:
  - Pure Python, no dependencies except mem0ai
  - ~120 lines of code per hook
  - Works with Claude Code's official plugin system
  - MIT licensed

  Just submitted a PR to the official Anthropic plugin registry: https://github.com/anthropics/claude-plugins-official/pull/52

  Happy to answer questions about the implementation or Claude Code plugins in general.

value: Show HN: Persistent memory for Claude Code using Mem0


value: postatic

value: Finally got around to launch something this year. This is my take on group card concept. Would love for people to try it out and provide feedback! Thank you all!

value: Show HN: Kardy – send a group card this Christmas

author: postatic


value: am-piazza

value:
I'm a software architect working on AI tooling and MCP. Last August I started writing again—by hand, every morning at 7am—after a 30-year detour from literature into engineering.
The workflow to transform handwritten pages into something shareable was painful: photograph, transcribe, edit, pair with an image, format. Each step a context switch.
So I built Vibrant Frog Collab to do it my way.
Core philosophy: AI enhances, doesn't replace. The app has guardrails baked in that can't be overridden—it won't generate content from scratch, only help develop what you've already written.
Features:
- Handwriting scan → instant transcription
- AI collaborative editing with memory across conversations
- Quote image creation (text on photos)
- BYOK: Claude, GPT-4 with your own API keys or Gemini with Google OAuth
- $9.99 one-time, no subscription, free version available
App Store: https://apps.apple.com/us/app/vibrant-frog-collab/id67562480...
Happy to answer questions about the technical side, the philosophy, or the writing practice.

value: Show HN: I built an iOS app for writers who still use pen and paper

author: am-piazza


value: hasibhaque

value: Show HN: I've open-sourced my habit tracker app built with React Native

author: hasibhaque


value: rukshn

value:
Hello HN,
Launching - https://entangle.cloud
Recently I was building an AI powered chat agent for a business that helps visitors to get information from the website by having a conversation with the AI agent.
I thought to provide the same service to anyone what find it useful.
Feel free to check it out and connect and I would love to work with you to have the same feature on your website.
It's still MVP so I will be personally working with you to have it implemented on your website.
See the project in action on my blog - https://ruky.me
Happy Holidays

value: Show HN: Entangle, AI powered knowledge agent for your website

author: rukshn


value: Show HN: Khaos – Kafka traffic simulator for observability and chaos engineering


value: QaysHajibrahim

value: Show HN: Runiq – I gave Claude 'hands' to control my OS (Go Binary)

author: QaysHajibrahim