Show stories

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!

TLDR: Librario is a book metadata API that aggregates data from Google Books, ISBNDB, and Hardcover into a single response, solving the problem of no single source having complete book information. It's currently pre-alpha, AGPL-licensed, and available to try now[0].

My wife and I have a personal library with around 1,800 books. I started working on a library management tool for us, but I quickly realized I needed a source of data for book information, and none of the solutions available provided all the data I needed. One might provide the series, the other might provide genres, and another might provide a good cover, but none provided everything.

So I started working on Librario, a book metadata aggregation API written in Go. It fetches information about books from multiple sources (Google Books, ISBNDB, Hardcover. Working on Goodreads and Anna's Archive next.), merges everything, and saves it all to a PostgreSQL database for future lookups. The idea is that the database gets stronger over time as more books are queried.

You can see an example response here[1], or try it yourself:

  curl -s -H 'Authorization: Bearer librario_ARbmrp1fjBpDywzhvrQcByA4sZ9pn7D5HEk0kmS34eqRcaujyt0enCZ' \
  'https://api.librario.dev/v1/book/9781328879943' | jq .
  

The merger is the heart of the service, and figuring out how to combine conflicting data from different sources was the hardest part. In the end I decided to use field-specific strategies which are quite naive, but work for now.

Each extractor has a priority, and results are sorted by that priority before merging. But priority alone isn't enough, so different fields need different treatment.

For example:

- Titles use a scoring system. I penalize titles containing parentheses or brackets because sources sometimes shove subtitles into the main title field. Overly long titles (80+ chars) also get penalized since they often contain edition information or other metadata that belongs elsewhere.

- Covers collect all candidate URLs, then a separate fetcher downloads and scores them by dimensions and quality. The best one gets stored locally and served from the server.

For most other fields (publisher, language, page count), I just take the first non-empty value by priority. Simple, but it works.

Recently added a caching layer[2] which sped things up nicely. I considered migrating from net/http to fiber at some point[3], but decided against it. Going outside the standard library felt wrong, and the migration didn't provide much in the end.

The database layer is being rewritten before v1.0[4]. I'll be honest: the original schema was written by AI, and while I tried to guide it in the right direction with SQLC[5] and good documentation, database design isn't my strong suit and I couldn't confidently vouch for the code. Rather than ship something I don't fully understand, I hired the developers from SourceHut[6] to rewrite it properly.

I've got a 5-month-old and we're still adjusting to their schedule, so development is slow. I've mentioned this project in a few HN threads before[7], so I’m pretty happy to finally have something people can try.

Code is AGPL and on SourceHut[8].

Feedback and patches[9] are very welcome :)

[0]: https://sr.ht/~pagina394/librario/

[1]: https://paste.sr.ht/~jamesponddotco/a6c3b1130133f384cffd25b3...

[2]: https://todo.sr.ht/~pagina394/librario/16

[3]: https://todo.sr.ht/~pagina394/librario/13

[4]: https://todo.sr.ht/~pagina394/librario/14

[5]: https://sqlc.dev

[6]: https://sourcehut.org/consultancy/

[7]: https://news.ycombinator.com/item?id=45419234

[8]: https://sr.ht/~pagina394/librario/

[9]: https://git.sr.ht/~pagina394/librario/tree/trunk/item/CONTRI...

I think LLMs are overused to summarise and underused to help us read deeper.

I built a system for Claude Code to browse 100 non-fiction books and find interesting connections between them.

I started out with a pipeline in stages, chaining together LLM calls to build up a context of the library. I was mainly getting back the insight that I was baking into the prompts, and the results weren't particularly surprising.

On a whim, I gave CC access to my debug CLI tools and found that it wiped the floor with that approach. It gave actually interesting results and required very little orchestration in comparison.

One of my favourite trail of excerpts goes from Jobs’ reality distortion field to Theranos’ fake demos, to Thiel on startup cults, to Hoffer on mass movement charlatans (https://trails.pieterma.es/trail/useful-lies/). A fun tendency is that Claude kept getting distracted by topics of secrecy, conspiracy, and hidden systems - as if the task itself summoned a Foucault’s Pendulum mindset.

Details:

* The books are picked from HN’s favourites (which I collected before: https://hnbooks.pieterma.es/).

* Chunks are indexed by topic using Gemini Flash Lite. The whole library cost about £10.

* Topics are organised into a tree structure using recursive Leiden partitioning and LLM labels. This gives a high-level sense of the themes.

* There are several ways to browse. The most useful are embedding similarity, topic tree siblings, and topics cooccurring within a chunk window.

* Everything is stored in SQLite and manipulated using a set of CLI tools.

I wrote more about the process here: https://pieterma.es/syntopic-reading-claude/

I’m curious if this way of reading resonates for anyone else - LLM-mediated or not.

The article describes the Mcp-CLI, a command-line interface tool for managing and deploying Apify cloud platform resources. It provides information on installing, configuring, and using the tool to perform various operations, such as deploying and managing actors, schedules, and datasets.

I was curious to see how some of the latest models behaved and played no limit texas holdem.

I built this website which allows you to:

Spectate: Watch different models play against each other.

Play: Create your own table and play hands against the agents directly.

While working on a proof of concept project, I kept hitting Claude's token limit 30-60 minutes into their 5-hour sessions. The accumulating context from the codebase was eating through tokens fast. So I built a language designed to be generated by AI rather than written by humans.

GlyphLang

GlyphLang replaces verbose keywords with symbols that tokenize more efficiently:

  # Python
  @app.route('/users/<id>')
  def get_user(id):
      user = db.query("SELECT * FROM users WHERE id = ?", id)
      return jsonify(user)

  # GlyphLang
  @ GET /users/:id {
    $ user = db.query("SELECT * FROM users WHERE id = ?", id)
    > user
  }

  @ = route, $ = variable, > = return. Initial benchmarks show ~45% fewer tokens than Python, ~63% fewer than Java.

Before anyone asks: no, this isn't APL with extra steps. APL, Perl, and Forth are symbol-heavy but optimized for mathematical notation, human terseness, or machine efficiency. GlyphLang is specifically optimized for how modern LLMs tokenize. It's designed to be generated by AI and reviewed by humans, not the other way around. That said, it's still readable enough to be written or tweaked if the occasion requires.

It's still a work in progress, but it's a usable language with a bytecode compiler, JIT, LSP, VS Code extension, PostgreSQL, WebSockets, async/await, generics.

Docs: https://glyphlang.dev/docs

GitHub: https://github.com/GlyphLang/GlyphLang

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.

The article provides an introduction to the Marten, a .NET document database and event store built on top of PostgreSQL. Marten offers features such as document storage, event sourcing, and querying capabilities, making it a versatile choice for building modern .NET applications.

The article discusses the SymFreq project, which is a frequency-domain signal processing library for Python. It provides a set of tools for analyzing and manipulating frequency-domain representations of signals, with a focus on efficiency and ease of use.

There is also a little command line tool to search jobs from command line. You can also use the web interface at https://jobswithgpt.com

Hi HN,

I’m working on an experimental 3D FPS game engine in C++20, aiming to deeply understand engine internals from first principles rather than just using existing frameworks.

Currently I'm strictly following LearnOpenGL docs.

This project focuses on: Entity-Component-System (ECS) architecture for high performance. OpenGL 4.1 rendering with a PBR pipeline, material system, HDR, SSAO, and shadow mapping. Modular systems: input, physics (Jolt), audio (miniaudio), assets, hot reload. A sample FPS game & debug editor built into the repo.

Repo: https://github.com/jackthepunished/horizon-engine

This isn’t intended to be a commercial rival to any commercial game engines.

it’s a learning and exploration project: understanding why certain engine decisions are made, and how to build low-level engine systems from scratch.

I’m especially looking for feedback on: Architecture choices (ECS design, render loop, module separation) Your thoughts on modern C++ engine patterns

What you’d build vs stub early in a homemade engine

Tips from experienced graphics/engine developers Criticism and suggestions are very welcome — it’s early days and meant to evolve. Thanks for checking it out!

Main tools on Kliga.com:

1) AI Music Detector

- Detects with 99.9% accuracy with smart models attuned to latest AI models. - You can upload an audio file or paste a Spotify track URL and Kliga analyzes whether the music is likely AI-generated or human-made. - It uses spectral + temporal analysis and gives a probability breakdown instead of a simple yes/no.

2) Audio Mastering

- 100% private, your songs never hit our servers - Preview with 12 Studio-grade presets designed by industry experts. - Download in HD-WAV 24 bit, MP3 320kbps for FREE. - No audio engineering required.

There are other useful tools like video compressor, audio cutter, etc. Do check them out.

Why I built this:

- AI-generated music is everywhere now, but it’s hard to quickly verify authenticity accurately.

- Most artists want to master their songs privately before releasing. They want one-click processing happening in their own device without having to download an expensive software.

Direct Links to main tools:

- AI Detector: https://kliga.com/ai-music-detector

- Audio Mastering: https://kliga.com/mastering

Happy to answer any questions. Thanks for checking it out!

I wanted to control the browser from the terminal so I made buse:

buse browser-1 # open chrome

buse browser-1 navigate "https://example.com"

buse browser-2 # open a second browser

buse browser-2 search "cat"

buse browser-1 observe # returns JSON about the page

buse browser-1 click 16 # clicks on the learn more link

I've been reading about agentic computer use and I tried to use MCPs and Browserbase, but there was just a lot of friction for me. So, I brought it to the CLI instead.

https://github.com/rinvii/buse

I deal with a lot of geometry stuff at work with computer vision and photogrammetry, which usually comes from the real world. It's seldom clean and neat, and I'm often trying to find a way to "make it nice" or "make it pretty". I've always struggled with what that really means formally.

That led me to shape regularization (a technique used in computational geometry to clean up geometric data). CGAL had implemented a few methods for that, but there are more ways to do it, which I thought were nice. Also I typically work in Python, so it was nice to have a pure Python library could handle this.

I struggled to get the first version working as a QP. At a high level most of these boil down to minimizing a cost A + B where A is the cost associated the geometry and goes up the more you move it, and B is the cost associated "niceness" or rather the constraints you impose, and goes down the more you impose them. Then you try and minimize A + B or rather HA + (1-H)B where H is a hyper-parameter that controls the relative importance of A and B.

I needed a Python implementation so started with the examples implemented in CGAL then added a couple more for snap and joint regularization and metric regularization.

Hi HN, I'm Kai Wang, one of the creators of Yuanzai World.

We built a simulation engine (currently on iOS & Android) that allows the community to create and share text adventures populated by multiple LLM-based agents. Unlike standard chatbots, our focus is on community co-creation—users define the worldviews, and our agents (with persistent memory and social relationships) bring them to life.

The cool part:

We implemented a system we call "World-Line Divergence" (inspired by visual novels like Steins;Gate). Usually, AI RPGs feel random or infinite loop. We built a state machine that tracks "World Deviation." If players interact with NPCs in specific ways (e.g., convincing an artist to change their style), it triggers a graph switch, leading to a completely different generated ending, effectively breaking the original script.

Tech Stack:

- Backend: Python / Java with a custom AI orchestration framework (to handle agent concurrency).

- Models: Hybrid routing between Gemini, GPT, and DeepSeek (optimizing for cost/performance based on task).

- Vector DB: Milvus (for handling long-term agent memory).

We are currently live on App Store and Google Play. Since it's a mobile-first experience, the link leads to our landing page where you can see the demo flow.

Would love to hear your feedback on the "World-Line" concept: Does this state-machine approach solve the aimlessness of AI RPGs?

Did you just wake up from a 20 year coma? Did you build a bunch of buzzword compliant web services back in the early 2000s and want all your SOAP and WSDL to be relevant again? Now you can put the smooth sheen of AI on your pile of angle brackets by exposing your SOAP-based web service as a Model Context Protocol (MCP) server.

This is my attempt in building a memory that evolves and persist for claude code.

My approach is inspired from Zettelkasten method, memories are atomic, connected and dynamic. Existing memories can evolve based on newer memories. In the background it uses LLM to handle linking and evolution.

I have only used it with claude code so far, it works well with me but still early stage, so rough edges likely. I'm planning to extend it to other coding agents as I use several different agents during development.

Looking for feedbacks!

I (17y/o) have been developing a rocket launch simulation that allows the user to explore what it's like launching a rocket from earth and putting it into orbit. This idea originally started as an educational simulation but as i've gone more down the rabbit hole the more i've wanted to make it realistic. The problem is that I've never had a formal orbital mechanics class or anything like that so I don't know what I'm missing, what I currently have implemented is:

  Variable gravity
  Variable Atmospheric drag (US Standard Atmosphere 1976)
  Multi-stage rockets
  Closed-loop guidance / pitch programs (works well within ranges 350km to 600km)
  Orbital prediction and thrusting options to change your orbit.

Current code and physics can be found at: https://github.com/donutTheJedi/Rocket-Launch-Simulation

Hi HN, I built this side project earlier this week. It executes an English auction on Solana with a reserve price of 0.1 SOL. Auction winner gets control of a Codex editor. Auction losers get refunded (minus a <$0.01 processing fee). The Codex agent operates in a sandbox and can only output HTML/JS/CSS.

The project is open-source: https://github.com/neelsomani/the-daily-auction

I built this as a personal open-source project to explore how EU AI Act requirements can be translated into concrete, inspectable technical checks.

The core idea is local-first compliance: – risk classification (Articles 5–15, incl. prohibited use cases) – bias evaluation using CrowS-Pairs – automatic Annex IV–oriented PDF reports – no cloud services or external APIs (browser-based + Ollama)

I’m especially interested in feedback on whether this kind of technical framing of AI regulation makes sense in real-world projects.

I wanted to run markdown files like shell scripts. So I built an open source tool that lets you use a shebang to pipe them through Claude Code with full stdin/stdout support.

task.md:

    #!/usr/bin/env claude-run

    Analyze this codebase and summarize the architecture.

    chmod +x task.md

    ./task.md

A script that runs your tests and reports results (`run_tests.md`):

    #!/usr/bin/env claude-run --permission-mode bypassPermissions

    Run ./test/run_tests.sh and summarize what passed and failed.

    cat data.json | ./analyze.md > results.txt

    git log -10 | ./summarize.md

    ./generate.md | ./review.md > final.txt

    for f in logs/\*.txt; do

        cat "$f" | ./analyze.md >> summary.txt

    done

One thing we didn't expect is that these are more auditable (and shareable) than shell scripts. Install scripts like `curl -fsSL https://bun.com/install | bash` could become:

    `curl -fsSL https://bun.com/install.md | claude-run`

The (really cool) executable markdown idea and auditability examples are from Pete Koomen (@koomen on X). As Pete says: "Markdown feels increasingly important in a way I'm not sure most people have wrapped their heads around yet."

We implemented it and added Unix pipe semantics. Currently works with Claude Code - hoping to support other AI coding tools too. You can also route scripts through different cloud providers (AWS Bedrock, etc.) if you want separate billing for automated jobs.

GitHub: https://github.com/andisearch/claude-switcher

What workflows would you use this for?

The article introduces miditui, a Python library that provides a graphical user interface (GUI) for working with MIDI data, allowing users to easily visualize and edit MIDI files without needing to write complex code.

Hey - I've been playing with LLMs since GPT-2 and recently experimented with fully generative UIs where the HTML/Canvas are generated just-in-time.

Every post on the feed( on slop/duck/storytime) you see is streamed and generated just-in-time with HTML and into a Canvas with Gemini 3 Flash.

Comments and DMs are bidirectionally linked with a Cloudflare Workers Durable Object which is why they feel so fast. Every generated post is saved into a DO SQLite which is then served into the "Following" feed so it can be served quicker.

This was inspired by Wikitok, a VSCode Extension I made around brainrot, and another fully generative UI site I made.

I built a macOS menu bar app to track Claude usage in real time via API after hitting limits mid-flow too often.

Signed and notarised by Apple. Open source.

https://github.com/richhickson/claudecodeusage

https://x.com/richhickson

GitHub profile analysis - Build your embedding from your Stars - Compare and discover popular people with similar interests and share yours - Generate a Skill Radar - Recommend repositories you might like

Hi HN!

"Never perfect. Perfection goal that changes. Never stops moving. Can chase, cannot catch." - Abathur (https://www.youtube.com/watch?v=pw_GN3v-0Ls)

StarCraft 2 is one of the most balanced games ever - thanks to Blizzard’s pursuit of perfection. It has been over 15 years since the release of Wings of Liberty and over 10 years since the last installment, Legacy of the Void. Yet, balance updates continue to appear, changing how the game plays. Thanks to that, StarCraft is still alive and well!

I decided to create an interactive visualization of all balance changes, both by patch and by unit, with smooth transitions.

I had this idea quite a few years ago, yet LLMs made it possible - otherwise, I wouldn't have had the time to code or to collect all changes from hundreds of patches (not all have balance updates). It took way more time than expected - both dealing with parsing data and dealing with D3.js transitions.

Pretty much pure vibe coding with Claude Code and Opus 4.5 - while constantly using Playwright skills and consulting Gemini 3 Pro (https://github.com/stared/gemini-claude-skills). While Opus 4.5 was much better at executing, it was often essential to use Gemini to get insights, to get cleaner code, or to inspect screenshots. The difference in quality was huge.

Still, it was tricky, as LLMs do not know D3.js nearly as well as React. The D3.js transition part is a thing that sometimes I think would be better to do manually, and only use LLMs for details. But it was also a lesson.

Enjoy!

Source code is here: https://github.com/stared/sc2-balance-timeline

Happy New Year! Here's a small turtle graphics game I made for my kids, that I want to share. You write the "DNA" of the turtle, and watch what happens.

Any comments or suggestions appreciated!

The article explores the impact of AI on the future of work, highlighting the potential for AI to automate various tasks and the need for workers to adapt and develop new skills to remain competitive in the job market.

Hey all- I just released a New tab replacement Chrome extension that makes browsing a lot easier - it also solves many of the annoyances with browser tabs. It's called Yellopages and it's free. Hope you'll give it a try.

* Groups all tabs from same domain. Makes it simple to kill all your Gmail tabs in one click (or keep just one).

* Groups all tabs playing audio. Toggle the sound for each one.

* Single text search for open tabs, bookmarks, and browsing history.

* Groups all tabs with new notifications (e.g. emails, likes, posts, replies, etc.)

* One click to kill all tabs (e.g. you're sharing screen in Zoom). A second click brings them all back.

I'm a solo web developer and I'm hoping to build an audience with my work. More at: https://buymeacoffee.com/kawaicheung