2025年7月16日 の Show HN

Hello HN,

I'm Ghita, co-founder of ZeroEntropy (YC W25). We build high accuracy search infrastructure for RAG and AI Agents.

We just released two new state-of-the-art rerankers zerank-1, and zerank-1-small. One of them is fully open-source under Apache 2.0.

We trained those models using a novel Elo score inspired pipeline which we describe in detail in the blog attached. In a nutshell, here is an outline of the training steps: * Collect soft preferences between pairs of documents using an ensemble of LLMs. * Fit an ELO-style rating system (Bradley-Terry) to turn pairwise comparisons into absolute per-document scores. * Normalize relevance scores across queries using a bias correction step, modeled using cross-query comparisons and solved with MLE.

You can try the models either through our API (https://docs.zeroentropy.dev/models), or via HuggingFace (https://huggingface.co/zeroentropy/zerank-1-small).

We would love this community's feedback on the models, and the training approach. A full technical report is also going to be released soon.

Thank you!

I authored and developed an interactive children's book about entrepreneurship and money management. The journey started with Twinery, the open-source tool for making interactive fiction, discovered right here on HN. The tool kindled memories of reading CYOA style books when I was a kid, and I thought the format would be awesome for writing a story my kids could follow along, incorporating play money to learn about transactions as they occurred in the story.

Twinery is a fantastic tool, and I used it to layout the story map. I really wanted to write the content of the story in Emacs and Org Mode however. Thankfully, Twinery provided the ability to write custom Story Formats that defined how a story was exported. I wrote a Story Format called Twiorg that would export the Twinery file to an Org file and then a Org export backend (ox-twee) to do the reverse. With these tools, I could go back and forth between Emacs and Twinery for authoring the story.

The project snowballed and I ended up with the book in digital and physical book formats. The Web Book is created using another Org export backend.

Ten Dollar Adventure: https://tendollaradventure.com

Sample the Web Book (one complete storyline/adventure): https://tendollaradventure.com/sample/

I couldn't muster the effort to write a special org export backend for the physical books unfortunately and used a commercial editor to format these.

Twiorg: https://github.com/danishec/twiorg

ox-twee: https://github.com/danishec/ox-twee

Previous HN post on writing the transaction logic using an LLM in Emacs: https://blog.tendollaradventure.com/automating-story-logic-w...

Twinery 2: <https://twinery.org/> and discussion on HN: https://news.ycombinator.com/item?id=32788965

Tiny MCP server → big new sense for LLMs.

Six functions (`current_datetime`, `time_difference`, `timestamp_context`, etc.) give Claude/GPT real temporal awareness: It can spot pauses, reason about rhythms, and even label a chat’s “three‑act structure”.

Runs locally in <60 s (Python) or via a hosted demo.

* Repo & README above * Full back‑story (open access): https://medium.com/@jeremie.lumbroso/teaching-ai-the-signifi...

Hi HN,

I built ggc (https://github.com/bmf-san/ggc), a terminal-based Git CLI tool written in Go.

ggc provides: - A fast interactive UI (like `fzf`) for common Git operations

- Traditional subcommands (e.g. `ggc add`, `ggc commit`)

- Git-compatible config support (`ggc config` reads from `git config`)

- Built-in aliases and workflow automation (e.g. `ggc addcommitpush`)

The goal is to improve developer productivity by combining interactive workflows with scriptable CLI operations.

It's still under active development, but I'd love feedback from the community!

GitHub: https://github.com/bmf-san/ggc Demo GIF: https://github.com/bmf-san/ggc#demo

Thanks!

I built DataRamen, a local-first SQL explorer that helps you get the data you need fast, without writing repetitive queries every time.

You run it locally from the CLI (no cloud version yet), connect your databases, and you're ready to go. The goal is to let you explore and query data like you would in a spreadsheet: intuitive, fast, and without friction.

Key features: - Automatic joins & related data navigation: Right-click any row to instantly see related records in other tables (based on foreign keys or references). - Keyboard-driven UI: Hit N to jump to a table, F to filter, and so on, it’s optimized for speed so you can go from question to insight in seconds (this point is still in progress, I find it confortable, but the goal is to make it even better). - Named tabs with saved queries: Keep multiple tabs open with different queries, useful for comparing or cross-checking data. Tabs are saved, so you can get back to your queries at any time. - Instant edit & insert: One click to edit or add rows, no need to write full queries. - Multi-DB support: Connect several databases and search across all of them. - Search across all columns: Find what you need even if you don't know the exact column.

If you've ever felt slowed down by writing the same SQL over and over just to explore your data, this might save you a ton of time. I’d love feedback or suggestions, especially from folks who wrangle data often.

Find more information on https://dataramen.xyz

PS. don't be harsh on the logo, I did my best :)

I had this idea where you would see realtime photos on a map, right now this is simply using cat pics, not sure where to take it from here but maybe it's useful to someone. :)

GitHub: https://github.com/stagas/worldsnap

I made clippy because pbcopy can't do something I needed every day: copy files to paste into GUI apps. When you pbcopy < image.png, you get raw bytes instead of a file that Slack or email can use.

Clippy fixes this:

- clippy report.pdf → ⌘V into any app uploads the file

- curl image.png | clippy → pipes become pasteable files

- clippy *.jpg → multiple files at once

- Text files still work like pbcopy

Technical: Direct Objective-C bindings via CGo. Copies file references (like Finder), not contents. Auto-cleans temp files. No AppleScript hacks.

Install: brew install neilberkman/clippy/clippy

Hey HN,

Every team I've been on has cobbled together some sort of combination of GitHub branch protections and custom scripts to make sure that PRs conform to organization policies and best practices.

Things like:

- When {X} file is changed, require review from team {Y}

- When a new db migration is added, ensure that a special set of tests pass

- Require multiple approvals when the PR is very large

- Add a special label to PRs that include breaking changes

- Allow emergencies / hotfixes to break glass and bypass all of the above

Most teams tend to start out with a little script running in GitHub actions to enforce all of these policies but it tends to get out of hand and become hard to maintain. PRs that should require scrutiny slip through the cracks, and others that should be allowed through are unnecessarily blocked.

That's why I made GitGuard (https://gitguard.dev/)

GitGuard lets you write and maintain these policies in a custom DSL so simple it looks like pseudocode. The policies are checked on every single PR nearly instantly (no need to wait for a GitHub actions runner) and the results are reported in plain english.

Right now policies can make simple assertions about PR metadata and take some stateful actions (adding labels, requesting review) but I'd love to hear more from HN about how GitGuard could be even more useful.

I built a browser-only dream interpreter that maps symbols to meaning using a custom keyword engine. No AI, no tracking, no backend it’s all deterministic logic, built with vanilla JavaScript. The idea was to see if emotional and symbolic interpretations could still feel personal without using machine learning. Dreams are parsed against a map of 300+ symbolic meanings. Everything runs locally in your browser and saves via localStorage. You can revisit old dreams, reflect on interpretations, or just explore what the system sees in your subconscious. Happy to answer questions, would love feedback!

Hey HN folks,

Last week I released the first public version of 120 HN — a fully native Hacker News client for macOS. This week, I'm excited to share version 0.2.1 with some essential updates:

The app now remembers window size, position, and sidebar state between sessions

Improved AI summaries: more concise, relevant with link back to the comments, easier to read with short paragraph form.

Minor tweaks to navigation and layout for a smoother experience

Sneak peek: local LLM support is coming in the next release.

As always, the app is free to use. Any suggestions or comments would be appreciated.

Thanks for checking it out.

Hello Hacker News,

I’m releasing TXT Blah Blah Blah Lite, an open-source plain-text AI reasoning engine powered by semantic embedding rotation.

It generates 50 coherent, self-consistent answers within 60 seconds — no training, no external APIs, and zero network calls.

Why this matters Six top AI models (ChatGPT, Grok, DeepSeek, Gemini, Perplexity, Kimi) independently gave it perfect 100/100 ratings. For context:

Grok scores LangChain around 90

MemoryGPT scores about 92

Typical open-source LLM frameworks score 80-90

Key features Lightweight and portable: runs fully offline as a single .txt file

Anti-hallucination via semantic boundary heatmaps and advanced coupling logic

Friendly for beginners and experts with clear FAQ and customization options

Rigorously evaluated with no hype, fully transparent

Try it yourself by downloading the open-source .txt file and pasting it into your favorite LLM chatbox. Type hello world and watch 50 surreal answers appear.

Happy to answer questions or discuss the technical details!

— PSBigBig

Do you remember IRC? If so, you probably remember bash.org

I got a bit nostalgic about it today, so I built a small tool: it shows a random bash.org quote as your terminal’s MOTD. If it made you smile, then it was worth making.

I built an Open Source CLI that lets you ask your Git commit history using natural language.

E.g ask the repo

•“When was login added?” •“What changed in the auth flow?”

It uses embeddings for the commit messages using configurable models (HF or OpenAI), stores them in ChromaDB, and queries them semantically with GPT via LangChain.

Features: • Fast local search (local storage) • Natural language query interface • Simple Typer-based CLI with commands to list and manage embeddings

Ideal for developers who want a smarter way to explore version history.

Feedback & Contribution Requested and Welcomed.

I made this app which tests your vocabulary. You have to name a word for every letter of the current word, and the last word becomes your new word. It's in beta. Looking for feedback!

This is a small personal project (completely free). The idea is that you practice typing on the real text you want to read.

Please give it a try and comment if you have any feedback for me (good or bad).

If you like it and want to see the development continue consider rating it on the chrome store as well. The more users it will have the more likely I am to invest more time into it.

Vibe-coded this after realizing I had way too many random thoughts that could be solid tweets. Just paste your stream of consciousness and it spits out sharp, tweetable hot takes. Supports OpenAI, Anthropic, and Google APIs. Your keys aren't stored anywhere. Open source: https://github.com/Zoz24/hot-take-generator

Would love feedback!

Recently I was learning a bit about TLS. This involved lots of capturing network traffic with `tshark`, then opening up wireshark to import the dump and check fingerprints, so I made this small service for easily checking.

curl https://tlsinfo.me/json or visit from your browser. It returns the TLS fingerprint that your request presented, including: JA3, JA3_r (raw), JA4 and JA4_r (raw).

No auth, QUIC supported, rate limited at 10 req/10s/IP to protect the server (pls be nice). Could be handy for:

- Playing around and learning about TLS.

- Debugging.

- Investigating how different clients/software leave different fingerprints.

- Adding one-liner fingerprint checks in tools or as part of an automation pipeline.

- Set up a reverse proxy or domain on cloudflare CNAME'd to tlsinfo.me and check their fingerprint.

Let me know if you find it useful. Reach out if you have any questions or ideas. Thanks.

Hi, I am an intern working for a town council election campaign.

Our democracy thrives on robust civic engagement, yet too often, public discourse becomes mired in ideological battles rather than focusing on solutions that truly benefit the community. Our candidate’s core message is that local issues must be approached non-partisanly: we need to put people over politics.

This approach aligns with the very essence of active citizenry. As civic leader Baratunde Thurston compellingly argues, to ‘citizen’ means to:

- Participate: Show up for each other and publicly participate in ways that include and go beyond voting.

- Invest in Relationships: Deepen relationships with ourselves, our community, and our planet and experience how we are all interconnected.

- Understand Power: Be fluent in power, and the various ways we can use it for our collective benefit.

- Value the Collective: Work towards outcomes that benefit the many – not just the few.

Inspired by the collaborative spirit of open-source development, and drawing on my background as a developer, we believe platforms like GitHub can be powerful tools for fostering this kind of inclusive civic engagement. The open-source model has proven remarkably effective in building communities and ensuring transparency, and we are exploring how to apply these principles to local governance.

To kickstart this initiative, we are developing a wiki and a discussion forum within this framework. Our vision is for this platform to serve as a central, accessible repository where all policy-related discussions, ideas, and proposals can be shared and developed collaboratively.

Share your thoughts!

I designed a tiny collapsible laptop stand that fits in your pocket and weighs less than a AA battery. It props up the back of your MacBook (or most laptops with a rear lip), and also works as a phone/tablet stand. After dozens of prototypes, I landed on a form that prints fast, folds flat, and actually feels stable. Site is live at https://floatystand.com Feedback welcome!

Also if you have a 3d printer, the files are available for free, just check the FAQs of the website.

Tool to generate documentation.

Try clicking the sidebar on the left.

A comprehensive Flask-based WhatsApp chatbot specifically designed for farmers and agricultural communities. The bot integrates with Google's Gemini AI to provide intelligent agricultural advice, crop disease identification, market information, and government scheme details. Built with conversation memory and multilingual support to serve farmers effectively.

Features Agricultural Intelligence: Specialized AI responses for farming queries, crop management, and agricultural best practices Crop Disease Detection: Image analysis for plant disease identification and treatment recommendations Market Price Information: Real-time crop price data and market trends Government Schemes: Information about agricultural subsidies, schemes, and farmer benefits Voice Message Support: Audio message processing with automatic transcription Multilingual Support: Translation services for regional language support Knowledge Base: Comprehensive agricultural knowledge database Conversation Memory: Maintains chat history for personalized farming advice WhatsApp Integration: Seamless integration with WhatsApp Business API Secure Communication: HMAC signature verification for secure webhooks Response Validation: Quality assurance for AI-generated agricultural advice

Just released my open-source project: Log Manager Real-time log viewer for remote servers via SSH — all in your browser.

As a full-stack dev, I often needed a way to tail logs across different servers without jumping into the terminal every time. So I built this tool.

Features: Add multiple remote servers

Define custom log file paths

Stream logs live (tail -f) via WebSocket

User authentication & secure access

Simple React-based UI

GitHub: https://github.com/bodyast/logManager

Perfect for:

Self-hosted projects

DevOps monitoring

Lightweight log dashboards

Built with love in Ukraine. If you find it useful, consider supporting the project: Monobank 4441 1111 2600 6190

Hi HN,

I’m the founder of Newsplash, a lightweight AI-powered news platform that delivers personalized, fact-based daily digests—no clickbait, no paywalled fluff.

⸻

Why I built it:

I found myself spending too much time sifting through sensationalist headlines and repetitive stories across major aggregators. Newsplash is my attempt to solve that: a tool that gives users a fast, trustworthy summary of the news that matters most to them—without the noise.

⸻

How it works: • ~500 articles pulled daily via NewsAPI • Deduplicated and cleaned with a readability parser • Summarized using GPT-4o (≈90–120 tokens per article) • Each user gets a unique daily digest based on topic preferences and feedback (likes/dislikes) • A built-in GPT chat tool allows users to ask contextual questions like: “Why does this matter for Nvidia’s stock?”

⸻

Stack overview: • Edge Functions: Deno (Supabase) for fetch, deduplication, and summarization • Database: Supabase Postgres for articles, preferences, digests • Frontend: React + Next.js (web), React Native + Expo (iOS) • AI: GPT-4o mini for summarization + article Q&A • Reranking: Simple cosine similarity on user feedback vectors

⸻

What’s live: • Web app with personalized digests • Feedback loop (like/dislike) that re-trains per user • Article-level AI Q&A • Free model

⸻

Next up: • Expanding digest customization (custom categories, source filters, articles per category) • Premium/ subscription product

⸻

I’d love your thoughts on: • Privacy/security best practices around everything. I don’t have a coding background so I have no idea • Ideas for building trust and transparency into AI summarization

Thanks for checking it out — Connor

Hi HN,

I’ve been working on an experimental AGI-like logic simulator using nothing but *pen, paper, and a structured table system*.

*What it does*: - Simulates logical relationships between concepts using a grid-based structure - Works like a hand-written neural net or rule-based system - Learns from user feedback (like reinforcement learning) by adjusting weights - Automatically generates reasoning paths and simulates calculation flows

*Why it’s interesting*: - No API, no GPU, no software required - Every reasoning step is transparent and explainable - You can literally *see the logic flow on paper*, like tracing neurons

*Use cases*: - Engineering problem solving (like mechanics or materials) - Simulating how humans think in step-by-step logic - Could evolve into a domain-specific expert system or educational simulator

Here’s a photo of the current prototype:

-> https://i.postimg.cc/4y0hB5rc/image.png

---

I’m curious if anyone here has tried similar “analog AGI” experiments — or sees potential use cases I’ve missed.

Happy to answer any questions or share more detail. Thanks!