2026年1月11日 の Show HN

Ferrite: Fast Markdown/Text/Code editor in Rust with native Mermaid diagrams

Built a Markdown editor using Rust + egui. v0.2.1 just dropped with major Mermaid improvements:

→ Native Mermaid diagrams - Flowcharts, sequence, state, ER, git graphs - pure Rust, no JS

→ Split view - Raw + rendered side-by-side with sync scrolling

→ Syntax highlighting - 40+ languages with large file optimization

→ JSON/YAML/TOML tree viewer - Structured editing with expand/collapse

→ Git integration - File tree shows modified/staged/untracked status

Also: minimap, zen mode, auto-save, session restore, code folding indicators.

~15MB binary, instant startup. Windows/Linux/macOS.

GitHub: https://github.com/OlaProeis/Ferrite

v0.2.2 coming soon with performance improvements for large files. Looking for feedback!

Hi HN!

My name's Robert Escriva. I got my PhD from Cornell's Computer Science department back in 2017. And three years ago I had a psychotic episode that irreversibly shook up my world.

Since then I've been applying a skill I learned in grad school---namely, debugging distributed and complex systems---to my own mind.

What I've found I've put into a [book (pdf)](https://rescrv.net/engineering-schizophrenia.pdf) on engineering, my particular schizophrenic delusions, and how people who suffer as I once did can find a way through the fog to the other side.

This is not a healing memoir; it is a guide and a warning for all those who never stopped to ask, "What happens if my brain begins to fail me?"

I am writing because what I've found is not a destination, but a process. It is an ongoing process for me and for people like me. I also believe it is automate-able using the same techniques we apply to machine-based systems.

I am looking for others who recognize the stakes of the human mind to engage in discussion on the topic.

Happy hacking, Robert

Building a 1D-Pong game is a bit of a rite of passage at the Chaos Communication Congress.

I was inspired by a version I saw at 38C3 and built my own interpretation for 39C3. Lots of people enjoyed playing it and even Elliot Williams featured it in his 39C3 Hackaday Podcast. And I can attest: it's truly fun because it's sooo simple at first sight - but wait until the speed increases... Not a bad work to fun created ratio for such a little project.

I used the opportunity to play around with Claude Code on my preexisting codebase to publish a nice-ish repo on GitHub. It worked great without any hitch or compile errors - impressive. What a nice way to test some capabilities.

Have fun with it an build your own version. And there are soooo many ideas that could be implemented. I am waiting for your feedback!

Will we end up with a league of networked 1D-Pong games? ;-)

Hi HN! I built VAM Seek because I was frustrated with 1D seek bars – you never know where you're going until you get there.

VAM Seek renders a 2D thumbnail grid next to your video. Click any cell to jump. All frame extraction happens client-side via canvas – no server processing, no pre-generated thumbnails.

- 15KB, zero dependencies - One-line integration - Works with any <video> element

Live demo: https://haasiy.main.jp/vam_web/deploy/lolipop/index.html

Would love feedback!

There's been a lot of discussion around the california budget and some proposed tax policies, so I asked claude code to research the budget and turn it into an interactive dashboard.

Using async subagents claude was able to research ~a dozen budget line items at once across multiple years, adding lots of helpful context and graphs to someone like me who was starting with little familiarity.

It still struggles with frontend changes, but for research this probably 20-40x's my throughput.

Let me know any additional data or visualizations that would be interesting to add!

Built this over the weekend to bridge the gap between "can hum a melody" and "can code algorithmic music patterns" (Strudel/TidalCycles) for live coding and live dj'ing.

What it does:

Real-time pitch detection in browser using multiple algorithms: CREPE (deep learning model via TensorFlow.js) YIN (autocorrelation-based fundamental frequency estimation) FFT with harmonic product spectrum AMDF (average magnitude difference function) Outputs: visual piano roll, MIDI files, Strudel/TidalCycles code All client-side, nothing leaves your machine Why multiple algorithms: Different pitch detection approaches work better for different inputs. CREPE is most accurate but computationally expensive; YIN is fast and works well for clean monophonic input; FFT/HPS handles harmonic-rich sounds; AMDF is lightweight. Let users switch based on their use case.

Technical details:

React, runs entirely in browser via Web Audio API Canvas-based visualization with real-time waveform rendering

The original problem: I wanted to learn live coding but had zero music theory. This makes it trivial to capture melodic ideas and immediately use them in pattern-based music systems.

Try it: https://dioptre.github.io/tidal/

Works best on desktop. Will work more like a Digital Audio Workbench (DAW).

Source: https://github.com/dioptre/tidal

A fun game for playing moral dilemmas with friends. I gave 12 AI agents zodiac personalities (not that I believe in them) using the same LLM with different personality prompts.

Hi All.

I made this as an fun intro to help people who have zero IBM mainframe experience and no access to a modern IBM mainframe (at least, not access to do whatever you want with it). I appreciate tips, suggestions and anything that might improve the experience for someone who has no idea of how those machines operate(d).

I analyzed 10 years of Hacker News data (2016-2025) to track Show HN submission trends.

- Show HN posts went from ~900/month (2016-2019) to 3,315 in Dec 2025

- Share of all stories: 2.4% (2016) → 12.8% (Dec 2025)

- Notable spikes: COVID-19 (2020), AI boom (2023), and accelerating growth through 2024-2025

Data source: HackerBook (144k Show HN posts / 3.4M total stories)

Most consensus libraries (Raft, Paxos) treat the state machine as a pure black box. This is fine until your state machine needs to actually do something, like charge a credit card, fire a webhook, or send an email.

If a leader crashes after the side effect but before committing it, you get duplicates. This is my attempt at fixing this problem from first principles ish: build chr2 to make crash-safe side effects first-class citizens.

mechanism:

Replicated Outbox: Side effects are stored as "pending" in replicated state. Only the leader executes them under a fencing token.

Durable Fencing: A manifest persists the highest view using atomic tmp+fsync+rename. This ensures a "zombie" leader can't wake up and double-execute stale effects.

Deterministic Context: Application code receives a deterministic RNG seed and block_time from the log, ensuring 1:1 state transitions during replay.

Strict WAL: Entries are CRC’d and hash chained. it is designed to prefer halting on mid-log corruption over guessing.

The Trade-offs: Side effects are intentionally at-least-once; "exactly-once" requires stable effect IDs for sink-side deduplication. It’s a CP system safety over availability.

Repo: https://github.com/abokhalill/chr2

if you’ve ever had “exactly once” collapse the first time a leader died mid flight, you know exactly why I built this.

Threw together this very specific proxy that allows the downstream to define which IP will be used for the proxied request, and has built-in rate limiting mechanism to coordinate upstream rate limiting across clients.

This is particularly useful when you have a proxy node with many IPs, and you either want to use a specific one, or rotate through them. It also helps prevent upstream rate limiting due to disjoint clients being unable to coordinate on rate limits.

Opus was largely able to one-shot each feature from my specs, which was pretty cool (shows how effective a spec is).

so you can start vibe-coding your ad-hoc terminal dashboard. With session replay and mouse click support built-in.

AI generates complete novels with cover art, ready for print Text: I built a tool that generates complete, print-ready books from a single concept. Enter your idea, pick a genre and length, and you get: Full manuscript PDF (formatted for print with title page, copyright, chapters) Editable DOCX file AI-generated cover art Print-ready cover PDF with spine The whole thing takes a few minutes. Output is sized for standard trim sizes so you can upload directly to KDP or other print-on-demand services. Built with Claude for the writing and image generation for covers. Priced starting at $19. Would love feedback on the concept and output quality. https://printreadybook.com

I recently shared a real case where DataMatrix-based automation exposed counterfeit pharma products across borders.

new in development, feedback highly appreciated =)

This is a small TailwindCSS alternative based on a css template literal. I was inspired by styled-components and EmotionCSS, which however do not work well with ViteJS and specifically Preact.

This provides a better experience than Tailwind, as you can use all CSS language features without learning new conventions while maintaining a per-component styling approach.

This also turns out to be more inspectable in the browser's dev-tools, as snippets are extracted as-is and are not fragmented across thousands of small classes.

I wanted something more optimized than other CSS-in-JS alternatives that generate CSS at runtime, so I created a ViteJS plugin for this. It extracts all style snippets, replaces them with classes like css-a1b2c3, and injects all the corresponding styles into a CSS file in place of an "@extracted-css" directive.

There is also a preact options hook that adds a custom "classList" attribute, which maps to clsx for easy class composition (similarly to VueJS, Svelte, etc.).

P.S. I know other frameworks exist, but I have really been enjoying using Preact for frontend development lately.

I kept running into the same problem in large codebases: “temporary” code almost never gets removed. People add TODOs, FIXMEs, or quick hacks to hit a deadline, and six months later nobody remembers why they’re there or who owns them. They quietly turn into production bugs. I built a small CLI that treats those comments as time-bounded instead of permanent. You can attach an expiry date to a TODO in the code, and when the date passes, CI fails and points to exactly where the expired code lives. It works by: scanning comments across any language parsing structured annotations and optionally using git blame to infer who added them and when I tried to keep it simple and CI-friendly rather than tied to any particular language or linter. Here’s the repo if anyone wants to look at the implementation: https://github.com/jobin-404/debtbomb I’d love feedback from people who’ve dealt with long-lived “temporary” code in production.

I’m an independent researcher proposing State Discrepancy, a public-domain metric to quantify how much an AI system changes a user’s intent (“the Ghost”).

The goal: replace vague legal and philosophical notions of “manipulation” with a concrete engineering variable. Without clear boundaries, AI faces regulatory fog, social distrust, and the risk of being rejected entirely.

Algorithm 1 (on pp.16–17 of the linked white paper) formally defines the metric:

1. D = CalculateDistance(VisualState, LogicalState)

2. IF D < α : optimization (Reduce Update Rate)

3. ELSE IF α ≤ D < β : warning (Apply Visual/Haptic Modifier proportional to D)

4. ELSE IF β ≤ D < γ : intervention (Modulate Input / Synchronization)

5. ELSE : security (Execute Defensive Protocol)

The full paper is available on Zenodo: https://doi.org/10.5281/zenodo.18206943

Inspired by TAWS. Built as a learning exercise.

GYESME is an early-stage, design-led project exploring alternative architectural approaches within the GNOME desktop ecosystem.

Rather than aiming to replace GNOME or ship a new desktop environment, the project treats GNOME as a platform and asks a narrower question: which behaviors and assumptions could be made optional or more cleanly abstracted without compromising a minimalist default experience?

The current focus is on research and documentation rather than implementation. Areas being examined include:

Architectural modularity versus extension-based customization,

Opt-in functionality for features that are disabled or removed upstream,

Preserving established Linux interaction patterns without expanding defaults,

Reducing unnecessary hard dependencies where practical, including systemd-specific assumptions,

The intent is not to “fix” GNOME or argue against upstream decisions, but to explore design tradeoffs around minimalism, flexibility, and long-term maintainability in modern Linux desktops.

At this stage, the project consists primarily of a concept site, documentation, and open design questions. Feedback on the framing, assumptions, and scope is very welcome.

Project site and repository: https://github.com/runleveltwo/GYESME

Thanks for taking a look.

I've always used benchmark.js for my benchmark tests, but I noticed that changing the tests order also changed the performance outcome. They were getting polluted between them somehow. V8 optimizations/deoptimizations maybe? I decided to take advantage of forking to do tests in completely separated processes with their own V8 instances, memory and so on, to avoid present and future optimization/deoptimization pollution.

Is my main benchmark library now (obviously), although not because "is mine", but because of the peace of mind. I've suffered the pollution one time and with this I avoid the paranoia in my head each time I do a benchmark: "will this maybe be polluted? let's reorder". And AI's help a lot to do some quick benchmarks without overthinking, like this example prompt:

Add a Buffer vs DataView benchmark using iso-bench. Read the npmjs iso-bench documentation including the Notes section.

If you are paranoid like me, well, here you have this tool.

GitHub: https://github.com/Llorx/iso-bench

I use voice dictation daily, but Wispr Flow at $144/year felt like too much for what it does.

So I built a minimal version: Hold Option → Speak → Release → Text appears at cursor.

- Works in any app - 100% local (WhisperKit), works offline - No account, no cloud

It's not as polished as Wispr or MacWhisper. But it's $1 and gets the job done.

If you run into any bugs, email me at [email protected] — I'll fix it. Helps me learn too.

Built with SwiftUI + WhisperKit. Happy to answer questions.

I built a Chrome extension that renders 2D/3D chemical structures directly on any webpage. It was originally designed to help with chemistry workflows in LLMs (like ChatGPT or Claude), where complex nomenclature is common but visual representation is often missing. How it works:

It uses a regex-based trigger chem:mol=name: to detect chemical markup. You can also right-click any IUPAC name or common name (like "benzene") to render it instantly. Key Technical Details: Rendering: Uses a custom engine to generate bond-line diagrams.

3D View: Integrated 3D rendering for molecules, minerals, and biological assemblies (proteins/viruses) from RCSB. Performance: Implements SVG caching and lazy loading to ensure it doesn't slow down the browser. Privacy: Only processes text matching the specific trigger pattern /\bchem:([^:]+):/g; no other page data is collected. I'd love to get your feedback on the rendering style and any suggestions for additional markup triggers that would be useful for scientific typesetting.

I did something that might be incredibly stupid. I made 25 specific predictions about what will happen in tech over the next 6 months — and published all of them with deadlines before I could chicken out. Not vague "AI will grow" predictions. Specific, falsifiable claims like:

Medical AI will face mandatory safety requirements within 18 months (regulatory signals are screaming) There's a ~6 month window in AI infrastructure before consolidation locks out new entrants Browser agents hit mainstream faster than current discourse suggests

Each prediction has a confidence score, a hard deadline, and what would prove me wrong. Why would I do this? Because I'm tired of pundits making unfalsifiable claims and retroactively declaring victory. "I predicted crypto would struggle" — okay, when? By how much? What counts as struggling? So I'm doing the opposite. Public predictions. Specific deadlines. No editing after the fact. The first verification check runs January 24. I'll publish results whether they make me look smart or completely delusional. A few already make me uncomfortable — some have conviction scores above 75%, which feels overconfident for 6-month horizons. But that's the point. If I'm not risking being wrong, I'm not actually predicting anything. All 25: https://asof.app/alpha What's your most contrarian take on what happens in tech this year? Curious what predictions HN would make with actual deadlines attached.

Hey HN

Ex YC/Google engineer turned indie maker here - excited to share something I just shipped.

The System Data in my Mac was taking up 300GB and it took me months to figure out how to clear the old cache, logs, junk and more. And CleanMyMac is a subscription - I refuse to pay subscription fees for Mac apps that run locally.

So I built FreeUpMyMac an offline, lifetime Mac cleaner that clear junk with 1 click. And helps you visualize your storage with TreeMap/Sunburst.

Hope it’s helpful to you as it is for me.

Would love your feedback

Tunde

Hi HN,

I’m a writer and solo developer. Over the last few years, I kept noticing the same thing: Whenever I sat down to write - essays, notes, drafts - the tools I used slowly pulled me away from writing and into everything else (folders, stats, formatting, metrics). Eventually, I found myself spending more time in the interface than on the words.

So I built featureless - a very small web app with just this:

- A single title field - One writing surface - Autosave - Clear, Undo, Upgrade, and Logout - No folders, no formatting buttons, no embeds, no word count

The goal isn’t to replace Notion, Ulysses, Obsidian, Word, Google Docs or other writing interfaces. It’s to offer a place where there’s nothing else to do but write, finish, and move on. Once you’re done, you can copy-paste the finished work into your preferred tool to polish or publish it.

It’s a web app, so anyone can try it directly in the browser: https://featureless.app

There’s a free tier with a short expiry window, and an optional paid plan if you want to keep a draft around longer. The idea is to introduce just enough constraint to encourage finishing.

I’d really appreciate any feedback. Happy to answer questions.

Cheers, Manoj

Remember Me AI introduces the Coherent State Network Protocol (CSNP) - a mathematically optimal approach to distributed AI memory that achieves:

40x cost reduction vs. traditional vector databases

Wasserstein-optimal memory coherence guarantees Zero-hallucination property through strict state consistency Provably stable long-term memory retention

The Problem Current AI memory systems (RAG, vector DBs) suffer from:

Memory drift: Context degradation over time Hallucination: Retrieved memories don't match original context

Cost explosion: Embedding storage/retrieval scales poorly

Coherence loss: No mathematical guarantee of consistency

The Solution: CSNP treats AI memory as a quantum-inspired coherent state with mathematical guarantees derived from optimal transport theory.

Shelfarr is a tool for cleaning and renaming audiobook libraries. It scans local files, matches available metadata, and produces consistent folder and filename structures, including series handling. All changes are previewed before applying, with support for dry runs and custom templates. The focus is on predictable behavior and user control rather than full automation.

This is a play website I built out with my 6 year old to show her that you can also build for the web (not just consume!). The idea was to make a bunch of small mini games (more coming) where you can learn some basic chess strategy. In this game you play a knight vs 3 kings who try to trap you. Try to survive for 15 moves.

Once you get bored of that, there's the classic radioactive pooping knights [1] ;). It's also wrapped up into an app [2] if that's better :)

Very keen for feedback :)

1. https://minichessgames.com/#/play/pooping-knights 2. https://play.google.com/store/apps/details?id=com.minichessg...

I built this MCP (Model Context Protocol) server to let AI agents easily publish, edit, and manage content on Write.as or self-hosted WriteFreely instances.

It's useful for automating AI-generated blogs, newsletters, or feeds without manual intervention.Key

features: 1. Publish/edit/delete posts and collections 2. Browse public feeds 3. Supports auth via access tokens

Python-based, installs via uv/pip

Motivation:

I wanted a simple way for AI workflows to integrate with privacy-focused platforms like (Write.as) WriteFreely.

It's early (v0.1.3), so feedback on tools like publish_post() or config would be great.

MIT license—fork/contribute if interested!

Repo: https://github.com/laxmena/writefreely-mcp-server PyPi: https://pypi.org/project/writefreely-mcp-server/

What do you think? Any use cases or improvements?

We’ve been working on production LLM systems and noticed a recurring issue: even well-crafted prompts fail under real-world conditions.

We wrote a technical breakdown of the failure modes (intent drift, hallucinations, modality violations) and why monitoring alone doesn’t prevent them.

Would love feedback from people running LLMs in production.

Hi HN,

Most group chats end up as endless scroll. Once a discussion gets interesting, context disappears, replies cross, and ideas get lost.

I built Qonvo as an experiment in a different direction: a realtime group chat where each message becomes a node, and replies create connections, so the conversation grows into a live visual map instead of a timeline.

How it works:

- Share a room link (no accounts) - Chat with 2 or more people - Messages appear instantly as nodes - Replying creates visible links - Shared #tags lightly connect related ideas - You can click any node to explore that part of the discussion

Rooms are temporary and auto-expire

You can export the conversation as JSON

There’s no AI trying to “understand” the conversation- the structure comes directly from how people reply and interact.

This started as a personal frustration with brainstorming and group discussions that feel rich in the moment but impossible to revisit later.

Curious whether this feels useful, distracting, or somewhere in between. Would love feedback on:

- whether the map actually helps thinking - what kinds of conversations this works best for - where it breaks down

Live demo: https://qonvo.xyz

Happy to answer questions and explain the architecture if useful.

Hi HN,

When production breaks, writing a clear and honest incident report is stressful and slow — especially while customers and teammates are waiting.

I built IncidentPost to solve that. You paste a raw outage timeline (alerts, Slack logs, timestamps) and it generates a professional, shareable postmortem with an executive summary, timeline, root cause, mitigations, and action items.

You can see a full demo output here: https://incidentpost.vect.pro/demo

Live app: https://incidentpost.vect.pro

It’s a one-time purchase per incident — no accounts, no subscriptions.

I’d love feedback from engineers, SREs, and founders who’ve had to write postmortems under pressure.

Hi HN,

I’m the creator of CharacterTest.app. I’ve always felt that traditional "Which character are you" quizzes were too static—relying on rigid branching logic that often yields predictable results.

To solve this, I built an engine that uses Immersive AI to perform semantic personality mapping. We integrate established psychological frameworks like the Big Five (OCEAN) and MBTI to create a more nuanced matching system. Instead of simple keyword matching, our LLM-based engine analyzes user inputs against a high-dimensional trait database covering 100+ fictional universes.

Key Features:

Scientifically-Grounded AI Matching: Leverages semantic analysis to decode user personalities into MBTI and Big Five dimensions before matching with character profiles.

100+ Fictional Universes: Extensive library covering TV shows, movies, and anime (from Stranger Things to The Dark Knight).

Frictionless & Private: No signup is required for basic tests. We believe in providing value before asking for data.

Global Fandom Support: Fully localized for English, Korean, and Japanese.

Technical Stack:

Framework: Built with Next.js (SSR) for optimal SEO and performance.

Core Logic: Custom prompting architecture to prevent "personality bleed" and ensure consistency across diverse fictional contexts.

I’d love to get the community's feedback on the accuracy of our trait-to-character mapping and the overall UX.

Thanks for checking it out!