2025년 9월 3일의 Show HN

A phonetic Arabic keyboard I created maps English letters to Arabic sounds, covering emphatic letters, hamza, and diacritics—making it easier for learners and casual users to type Arabic.

TLDR A small, vendor-agnostic inference loop that turns token logprobs/perplexity/entropy into a single, targeted refinement pass for small LLMs.

What it does - Captures logprobs/top-k during generation, computes perplexity and token-level entropy.

- Triggers at most one refine when simple thresholds fire; passes a compact “uncertainty report” (uncertain tokens + top-k alts + local context) back to the model.

- In our tests on technical Q&A / math / code, a small model recovered much of “reasoning” quality at ~⅓ the cost while refining ~⅓ of outputs.

Why I built it I kept seeing “reasoning” models behave like expensive black boxes. Meanwhile, standard inference already computes useful signals both before softmax normalization and after it(logprobs), which we usually throw away. This loop tries the simplest thing that you could think of: use those signals to decide when (and where) to think again.

How to try it GitHub (notebook + minimal code): https://github.com/monostate/weave-logprobs-reasoning-loop Paper (short & engineer made): http://arxiv.org/abs/2509.00079 Blog (more context): https://monostate.ai/blog/entropy-refinement-blog

Requirements: Python, API that exposes logprobs (tested with OpenAI non reasoning 4.1). OPENAI_API_KEY and WEAVE for observability. Run the notebook; it prints metrics and shows which tokens triggered refinement.

Stack / notes - Python, simple loop (no retraining). - Uses Responses API logprobs/top-k; metrics: perplexity, max token entropy, low-confidence counts. - Weave for lightweight logging/observability (optional).

What I learned / things that mattered - Passing alternatives (not just “this looks uncertain”) prevents over-correction. - A simple OR rule (ppl / max-entropy / low-confidence count) catches complementary failure modes. - Numbers drift across vendors; keeping the method vendor-agnostic is better than chasing fragile pairings.

Limitations / caveats - Needs APIs that expose logprobs/top-k. - Results are indicative—not a leaderboard; focus is on within-model gains (single-pass vs +loop). - Thresholds might need light tuning per domain. - One pass only; not a chain-of-thought replacement.

Asks / feedback - Run it on your models and ideas (e.g., 4o-mini, v3, Llama variants with logprobs) and share logs in a PR for our README in GitHub if you'd like, PRs welcome - I’ll credit and link.

Overall let me know if you find making small models reason like this useful!

Hey HN,

I’ve been a PM for 3 years, and one hard part was always understanding why users churn, drop off and behave the way they do!

Session replays had the answer, but watching hours of them was painful.

I chatted with a bunch of founder friends and PMs and they too had similar troubles.

So I built Chibi an AI that watches replays and tells you what’s broken, confusing, or causing drop-off.

Long Term: I'm thinking if Chibi could evolve into an AI product manager co-worker that can detect and prioritize issues, think through features and even run A/B tests.

Tech Stack: Elixir + Phoenix, rrweb and gemini

Would love to know what you think :)

Happy to answer any questions too

Hi HN, I'm the creator of this project. For the past months, I've been working on building an AI agent that could move beyond simple generation and tackle inventive challenges autonomously. The core idea was to create a system with a "metacognitive loop"—the ability to recognize when it's stuck on a fundamental problem and then launch a sub-mission to solve that specific bottleneck before continuing. The linked article is a deeper introduction to the system's architecture and a snapshot from a recent run. I tried to design it to be evidence-grounded and self-critical to avoid the pitfalls of hallucination. Happy to answer questions RW

The idea for TwoTickets started when my wife and I had two tickets to Hamilton, and she couldn’t make it at the last minute. I realized how awkward it is to want to go to a concert, game, or show but not have someone to share it with — and how current apps either constrain you to your circle or to endless swiping.

On TwoTickets, you Twoot an event in order to connect with others around that shared plan. The flow is simple: Twoot → Match → Chat → Decide → Go. You don’t see profiles or matches until you Twoot events, so plans come first and profiles second.

The aim is to make meeting new people more natural: the event itself is the ice-breaker, not a random line in a bio. We’re in soft launch now and would love feedback from HN — does this “event-first” approach resonate with you, and where do you see the pitfalls?

Paul Graham once said that all dating apps are really just matching apps. I wonder: how close is this to a solution to that assertion — although TwoTickets is broader than dating.

*Links:* - Website: https://www.twotickets.us - iOS App: https://apps.apple.com/us/app/twotickets-match-eventfully/id...

This tool lets you live-edit Tailwind CSS classes directly in the browser. Inspect, navigate the DOM, get real-time class suggestions, tweak, preview, copy - all without switching to your code editor. Supports both v3 and v4 versions of Tailwind CSS.

Try it live here - https://taillens.io

Built QueryWeaver, an open-source text2SQL tool that uses a graph to create a semantic layer on top of your existing databases. When you ask "show me customers who bought product X in a certain ‘REGION’ over the last Y period of time," it knows which tables to join and how. When you follow up with "just the ones from Europe," it remembers what you were talking about.

Instead of feeding the model a list of tables and columns, we feed it a graph that understands what a customer is, how it connects to orders, which products belong to a campaign, and what "active user" actually means in your business context. We used FalkorDB for the graph part because it handles relationship mapping better than cramming table schemas into prompts. Graphiti tracks the conversation so follow-ups actually work. Final notes: Your data stays in your databases. We read from existing schemas, never migrate data. Standard SQL outputs you can run anywhere. We've built an MCP and you can generate an API key to take it for a spin. Please, tell us how it’s working out for you!

This weekend I built a multi-agent coding system which, quite unexpectedly, beat Claude Code on Stanford's Terminal Bench!

The architecture is straightforward, consisting of an orchestrator agent that deploys explorer & coder subagents to complete complex terminal based tasks, utilising an intelligent context sharing mechanism along the way which makes it all work.

The repo has a lot of technical details, and all the code and prompts for you to play around with if you'd like!

I had a lot of fun making this, I hope you have fun reading the README, using it yourself, or even extending it!

As always, a huge thanks to the great team behind Terminal Bench. It is a great benchmark.

Thanks for reading, Dan

I've been working on it as a side project and would love to get some feedback or contributors

Hi All,

For the lack of a clean, accurate and feature heavy json comparison tool out there. I made jsontoolbox compare tool.

This is the only tool that- - does real time comparison - shows JSON path dynamically as you navigate the json - allows type/paste in, import from file or drag-drop 1/2 files in the editor to compare - lets you choose if you want sync-scroll or not - sorts both json (only)if you like to see a sorted diff - lets you swap both json - lets you download each json separately with a custom file name - works completely on client side - has no ads - has dark/light mode

It is also one of the best JSON Formatter/Minifier out there :)

I know there is a sea of such tools out there, but as a developer none were good enough for my use case. Please try it out and share feedback.

Hi y’all,

Just came across a crate on crates.io that recently hit v1.0.0. It’s called rkik - basically a "dig for NTP". I hadn’t seen a tool like this in Rust before.

Looks pretty handy: it can query and compare NTP servers, output JSON for monitoring, and even run continuous checks. Seems to be getting some traction in the Rust community - might be worth a look if you’re into System administration, networking or DevOps.

I wrote this script to quickly retrieve raw file URLs from public GitHub repos. Added to my ~/.zshrc, it’s now a fast, reliable tool in my caveman workflow. Maybe you'll find use for it too! Have a great rest of your day, everyone!

Hey HN,

I built a tool that generates a video explanation from a pdf link to a research paper using AI.

Just paste in a PDF link, and it creates a narrated video that deeply explains the paper, including detailed explanations of plots and figures. The goal is to make digesting research papers require a bit less effort.

Link: https://researchpapervideos.com/

Would love to hear what you think!

I recently purchased an SH1107G-based OLED and found no Rust driver that worked in a synchronous, no_std environment.

So I wrote my own driver, and along the way implemented a *1.3KB algorithm to search and verify the initialization sequence* on an Arduino Uno.

Key features: - Iterative topological sort to explore init sequences - Optimized for AVR constraints using bit flags and static arrays - Utilities: I2C scanner, hex/binary dump, serial adapter

This actually initializes a Grove OLED on Arduino Uno using just 1.3KB SRAM.

Code & docs: https://github.com/p14c31355/dvcdbg Crate: https://crates.io/crates/dvcdbg

Hi HN,

I’ve just released fst, a minimalistic C utility that provides comprehensive statistics about directories. It’s designed to be fast, with no dependencies, and is fully statically compilable.

Features:

Counts of files, directories, empty files/folders

Classifies binary, text, and script files

Displays min, max, and average file sizes

Identifies recent and oldest files

Lists executable files, symbolic and hard links

Supports human-readable sizes and recursive stats

Key Points:

Written in pure C, minimal dependencies, lightning fast

Works on both ARM and x86 architectures, fully statically compilable

Can run with no arguments (defaults to the current directory)

Licensed under LGPL 3.0

GitHub repository: https://github.com/Ferki-git-creator/fst-ferki

Submitted to GNU for review

I'm seeking feedback, ideas, and contributions from the community. The goal is to enhance usability, add more metrics, and possibly extend internationalization support in the future.

Any thoughts or suggestions would be highly appreciated!

I made OS (MIT) "Deep Researcher" web app based on Node.js. The app searches internet or, if nudged, the scientific articles databases, then creates structured reviews with in-line citations based on user's request.

The app requires your own api key to run OpenAI's LLMs and the web search tool. The LLM vendor can easily be swapped for another but the web search tool substitution will require work.

- GitHub repo: https://github.com/Antibody/deep-researcher-node

I spend most of my time in the Nushell terminal and wanted an easy way to query my way around large Rust programs. I also wanted to use LLMs to keep documentation up to date and find places my docs are starting to lie. So I made rust-ast. It scripts ast-grep under the hood to turn Rust repos into nice structured data.