value: squid-protocol

value:
The leaderboard ranks every country by average score, which then can be dissected by state/province/prefecture.
Uses modern teaching techniques (immediate feedback, positive feedback, proof of growth, rewards practice not just perfection).
Campaign mode for infinite number board expansion. How high can you get?
Once I get enough data, I plan to offer fun statistics in the leaderboard like:
"Congratulations! You outscored 46% of 10-13 year old Danish people"
"Congradulations! You are better at multiplication than 867 70-80 year old Mexican individuals"

value: Show HN: A fast paced multiplication game with an international leaderboard

author: squid-protocol


value: mslaviero

value: Our solution to the software supply chainpocalypse, a proxy for common package tools, instead of a wrapper. It allows for central configuration of package policies.

value: Show HN: Package Proxy

author: mslaviero

title: Show HN: Package Proxy


value: findpcpart

value:
I've built a website where you can browse PC parts from Amazon without distractions and clutter.
Most people, like myself, value more information and a clear way to find products than being bombarded with irrelevant stuff like "hey buy this item too" or "people also buy this" Sometimes you need to scroll too far down just to see actual specs. So I decided to make it simple, just a list of products and some filters to find what I need.
If you value a distraction free, no clutter way to find what you need, check it out: https://findpcpart.com
In the future, I plan to extend it and provide more info for each product.
If you have any questions or suggestions, feel free to comment below.

value: Show HN: Browse PC Parts on Amazon.com without distractions

author: findpcpart


value: jackjayd

value: Show HN: Fast Android File Manager that works

author: jackjayd


value: arashfratto

value: Show HN: Netlora diagnose bufferbloat and why fast internet feels slow

author: arashfratto


value: Show HN: Jo – AI-native language to catch prompt injection at compile-time


value: Show HN: Piqc – An open-source GPU waste scanner for LLM inference clusters


value:
For a long time, I've wanted a way to do realtime family/friend location sharing with e2ee.
So I finally built one!
Some details:
- The protocol uses a Signal-style double-ratchet (though with some differences) for PFS/PCS (but no PQ, a la SPQR)
- For simplicity and privacy, there's no persistent user identifier--just sessions. If you lose your phone, you and your friends have to re-pair.
- Message sharing uses ephemeral "mailbox tokens" to make social network/metadata analysis difficult.
Technical details here: https://where.af0.net/technical. Github here: https://github.com/danmarg/where.
Thrilled to get feedback!

value: Show HN: "Where" is an open source E2EE realtime location sharing app


value: JoniMartin

value: Show HN: InferBench – Benchmark local LLM engines with one click

author: JoniMartin


value:
I'm a heavy LLM user in both coding and UX design, but I've found that LLMs have an addictive quality because they provide a form of instant gratification. I wanted an app to do a few things:
1) Help me take some explicit time away from an LLM, where I don't use AI for work, life, etc.
2) Encourage me to think in my own words and formulate my own thoughts.
3) Provide a place to go write something when the addictive reflex kicks in to ask the AI to generate something.
The app lets you start a timer and walk away. When you feel the urge to ask the AI to think for you, you go back to the app and it asks you a random question that encourages you to formulate a thought. Essentially "do a mental push up" when you were about to reach for the easy button.
It saves locally what you write if you choose. When you end the session it tells you how long you went. No logins or trackers.

value: Show HN: 0llm is a small app to help you spend time away from AI


value:
This is a POC of an idea I've had for a while. Rather than using LLMs to generate code, what if we could just write a software image directly into memory?
At the end of the day, programming languages are an abstraction to make development easier for humans. Using an LLM to write code is like having someone else chew your food and spit it into your mouth--it gets the job done, but it would be faster to just cut out the middleman.
To that end, I'm using a diffusion model to generate images for a Von Neumann VM. The model treats the VM machine state as an image (literally saveable as a .bmp) with pixels representing bits. To reduce nondeterminism and noise, several direct x0 predictions are made and their logits are averaged, with the result thresholded into binary pixels.
Because the diffusion model may still make occasional pixel-level errors, the image stores important logical bits multiple times, and the decoded value is chosen by majority vote.
It's not perfect (and right now it's just capable of basic arithmetic) but the result is an executable image, generated in one-shot, stored in a small 72x72px .bmp.
I'd love to hear some thoughts on this!

value: Show HN: One-Shot Program Generation Through Direct Memory Diffusion


value: onprema

value: amongst my friends and family, i am the "garden guy", and often get asked questions about what to plant and when to plant it. there are a lot of great resources online, but can be overwhelming for someone who wants to get into gardening and growing their own food.<p>so, i made this site as a free resource for people who want to know what plants can grow in their area, and when they should be started.

value: Show HN: What Grows Well

author: onprema

title: Show HN: What Grows Well


value:
I’ve been building an open-source project called Agents Remember, and I think it might fit the discussion here because it started as “how do I make coding agents remember my repo?” but turned into a broader question:
What should memory for agents actually be?
The basic idea is simple: coding agents are good at local edits, but they often miss the project-specific knowledge that experienced engineers carry around in their heads.
The memory itself is Markdown and Git-based. A source file can have a matching onboarding file. Route overviews describe larger areas. A ledger called memory.md maps code commits to memory commits, which gives an anchor between the memory repo and the code repo which are physically seperate in external mode. Some people don't want to have a huge amount of markdowns in their code repo. The ledger runs a lookup table so you can go back to earlier versions of that memory and still have synchronicity. Which is very helpful when you want to restore it from a bad state. This lookup table also allows you to run code and memory in dual worktrees and with that keep changes to the memory local until your feature or refactor etc. is clean and ready to merge. This protects your memory main from corruption. In other words it is like code and turned into a first class citizen. And it uses the same git mechanics to protect it.
With isolated work environments you also get seperate code graph and grepai instances using docker. Their memory is getting cloned with minimal changes so they map cleanly into the new environment. The cloning avoids re-indexing. So providers can be spun up and thrown away with the isolated environment.
For verifying memory every doc markdown file has a header that tracks the last known commit hash of the code file it is tracking. A simple script makes that way staleness detection cheap. This is one of the main reasons why I decided to use a path-mirrored documentation method. The documents mirror the same path but in a parallel folder. That makes not just staleness detection simple but also retrieval. The agent that opens a code file knows automatically where the document is and also has the assurance that the material is highly relevant.
Overview.md are more difficult to invalidate because they cover routes even the entire project. As the name says they give broader overviews which helps to get the gist. That broadness makes validation more challenging. But validation is still possible deterministically by using hot-paths within and script generated index files that monitor routes that change or larger file movements. So the model gets a clean deterministic signal and knows which parts of the overview files it has to update by pulling up git diffs or just looking into the file level markdowns that tell the story.
Another interesting part is the split of responsibility. The model should not have to manually track everything. It should reason with the developer, frame the problem, surface assumptions, compare options, and ask for the right approvals.
The deterministic work gets offloaded to an MCP server.
My system routes every session through a lifecycle:

    request → trust check → reframe/research → decide → build → close

Before coding, the agent has to resolve context, check drift/provider state, reframe the task, gather evidence, and wait for developer agreement. Implementation approval is not commit approval. Commit, push, PR, merge, cleanup, and memory carryover are separate gates.
A pattern that has become important recently is evidence accounting. For deeper research, the agent records what kind of evidence it used.
Is this still “AI memory” in the usual sense, or is it more like agent operating context?

value: Show HN: Agents Remember – Git-aware memory for coding agents


value: patethegreat

value:
Hey HN, Lich is a worktree aware local dev stack orchestrator. Simply put, it allows you to run multiple copies of your development stack from different worktrees with different code in parallel without going insane. I built Lich because I’ve found myself increasingly using multiple parallel coding agents for development work. I wanted my coding agents to each have independent copies of my development stack to be able to test and validate their own work well. I found that trying to do this totally broke the way I have normally setup tooling for local development. Ports conflict, the UI from one worktree connects to the backend or DB from another one, logs are hard to track down because agents start stacks in the background, any reliability problem sends agents down a rabbithole trying to fix it.
I originally built around 5k lines of bash scripts to solve this problem for a single relatively complex application was able to do it, but I realized that for any future thing I might work on I would have to build that whole setup again even though it’s not really that coupled to the specific application I’m working on. I realized I could build a clean, re-usable abstraction to solve this problem robustly and comprehensively for practically any repo through a standard lich.yaml definition and a simple CLI that manages the stack lifecycle, port allocation, log management, and garbage collection. That is what lich is.
You might wonder: why can’t I use docker compose to solve this problem? (or insert other existing tools here). The simple answer is you totally can, but it has two issues:
1. These tools really weren’t built for this use case, they might be able to support it but you’ll end up building a lot of custom tooling to make it possible. Though some tools make it easier than others.
2. If you find a tool that happens to be pretty good at solving this problem, you typically end up needing to adopt its conventions and opinions for your entire stack. Simply put, I don’t want to dockerize all of my services just to be able to run multiple copies of my stack in parallel.
Lich is intentionally designed to be un-opinionated. It sits on top of and drives whatever tooling you already have.
If you have a simple app (just a nextjs app with a development workflow that uses only a hosted testing db for example), you might find that you don’t need lich. That’s probably right. Lich is most useful when you have a relatively complex repo with multiple different services and you also want to run a copy of the DB locally. If you’re thinking about dynamically allocating ports in your startup scripts or managing state and logs, you probably need lich.
I use lich daily to run 3-5 independent stacks in parallel from different worktrees for a complex application with 5+ services and multiple docker containers per stack.
I’ve released Lich as open source with the MIT license. There’s a demo video in the GitHub readme showing me using Lich to start a dev stack in the main workspace of the lich t3 starter repo and then spawn 5 parallel subagents through Claude Code that each make an edit to the template homepage and then spawn a separate copy of the stack with it’s own DB in parallel.
The easiest way to try out lich is to use that t3 starter repo. You’ll find instructions in the GitHub readme: https://github.com/RPate97/lich

value: Show HN: Lich, start a dev stack per coding agent in parallel

author: patethegreat


value: sixhobbits

value: Show HN: 2Draw – co-operative pictionary built with TLDraw inspired by Drawful

author: sixhobbits


value:
I couldn't find a nice worldcup bracket visualizer out there so ended up building one. It's nicer than the ones I saw out there. There is no login, no ads, runs client side, uses localStorage and all the state is encoded in the URL itself and you can share it.
The calendar feature is nice. I wanted to build my own schedule for the games I was interested in. There is full calendar that you can subscribe to as well, that gets updated as the fixtures get decided. I also wanted to be able to interactively change things and visualize the whole knockout stage.
All the state is in the URL fragment. It's a handrolled compact byte format. About 203 bytes, ~217 characters. The URL has the full snapshot so the link you share always renders the same brackets. It's versioned so I can change the format and not break links out there.
At this point it does everything I wanted it to do for me. Might be some real howlers in there. Let me know if you spot one.

value: Show HN: Group of Death – WorldCup bracket predictor with shareable URLs


value: dsatrainer

value:
Ran 2 monitors for months practicing leetcode. One with ChatGPT up in 'study mode' asking the same questions over and over for ever LC problem, and the other on LC trying to understand what do.
Got tired of the set up and ended up building DSA trainer built around my most common asked questions when I was trying to learn.
Explains the concept in a Q&A type format that guides you to the data structure, explains why it's optimal, shows the brute force method and explains why that won't pass the interview, and has a 5-rung hint ladder, dry run table, and common 'gotchas'.
Pattern pages that explain the foundations and the strengths/weaknesses of each data structure or algorithm and when to reach for them.
Also has Cold Read drills for word-based problems that you can individually or in sessions.
Any feedback would be appreciated!

value: Show HN: DSA Trainer, LeetCode practice with a hint ladder instead of spoilers

author: dsatrainer


value: bmillare

value: For making it easier to iterate with an LLM on Decision Matrices. Try it: https://bmillare.github.io/design_in_practice_ui/

value: Show HN: A Simplistic UI for Rich Hickey's Design in Practice

author: bmillare


value: leomos

value:
Hello HN,
I built this tool to compare multiple solar panels for my rooftop and get a monthly energy production report based on input location.
Some notes:
- calculations are done using PVGIS
- the only supported rooftop shape is rectangular (for now)
- it's possible to upload a solar panel PDF datasheet or parse a URL containing the details but in this demo instance I only allow the access to a static catalog of ~10k solar panels (LLM inference costs :D)
Feedbacks are more than welcome,
Thanks!

value: Show HN: Solectio – design, compare and share rooftop solar configurations

author: leomos


value: msalsas

value: Show HN: Amanuensis – a local-first AI persona that won't fabricate facts

author: msalsas


value: chrillemn

value: Just released a new version (0.6.7)<p>What do you think?

value: Show HN: VSCode Extension for .env

author: chrillemn

title: Show HN: VSCode Extension for .env


value: therealmacsteel

value: Show HN: SteelWorks, a free-first autonomous business OS

author: therealmacsteel


value: Nayjest

value: Show HN: Gito v4.1.0 – AI code reviewer now runs on Claude Code / Gemini CLI

author: Nayjest


value: adithagrawaal

value: Show HN: SnapToCode – Screenshot any UI and get clean Tailwind code

author: adithagrawaal


value: rfgplk

value:
Howdy HN,
I've been working on micron for quite some time now, and I've finally gotten it to a state where I'm ready to share it with other people. I've really been pruning and testing it quite heavily for the past few weeks looking to flush out any bugs/inconsistencies. micron is a header-only C++23 core systems library that runs on Linux without libc, without libm, without the STL, and without any external dependencies at all. Fully freestanding. To my knowledge this is probably the only project of this kind, and the only libc implementation not in C. There _might_ be some Rust libc variant out there but I couldn't find any.
Why does this exist?
The STL makes a lot of decisions I disagree with; favoring generality over performance, safety theater that doesn't actually help anyone, ABI stability over bringing novel features to the language (regex, filesystem && company), and generally either being outdated compared to standard libraries of other languages or shipping solutions that are low performance (usually both).
I wanted a library that treats the developer as the expert and makes development genuinely _simple and fun_. Every container in micron was written with that in mind. Most algorithms have hand-rolled SIMD loops wherever the math allows it, across amd64 (up to avx512), AArch64, and ARMv7 NEON.
The other reason is hard determinism and portability sanity. glibc is _obscenely_ bloated, making it painful to compile quickly, painful to port, and painful to reason about. Half of Linux distros don't properly ship cross-arch libc; the ones that do are often missing static versions; and just getting a truly static binary out of glibc is a battle all its own (Fedora doesn't even _ship_ static libc properly in their official repos because security). Cross-compiling for ARM32 on an amd64 host is a special kind of misery if you're depending on the system libc. micron eliminates that entire class of problem. There's a single flat source, header only, and you're done; same code, same behavior, whether you're targeting a server or a microcontroller-class Linux board.
Performance wise _most_ implementations in this library are either on par with the Standard Library (for things that can't be meaningfully sped up like container accesses) or greatly faster, near bleeding edge of what is out there. (one little side note is that right now most math kernel implementation code is more or less hardcoded for avx2 chips, there's no avx512/avx10 layer, so if you have a super modern cpu you won't get maximal performance over there).
As of right now, the library is _almost_ feature complete (at least to the point where I'd like to have it). There's a full linux sys layer (maps more or less all syscalls, the ones that aren't you have a full syscall table so you can call them whenever ie. syscall(SYS_*, ...)), full math implementation, containers (contiguous, maps, trees, sets, heaps, queues), strings, a full simd layer port (for amd64 + arm neon), concurrency (mutexes, atomics, threading), io, functional programming primitives, a semi complete gfx layer (OpenGL/Vulkan)... micron also ships with a full memory allocator inlined, so you don't need to depend on anything externally.
micron currently supports amd64/i386/aarch64/arm32 ONLY and is Linux ONLY. It might run on macOS, but no guarantees on that since too many things right now are effectively Linux hardcoded. Oh and you probably want at least kernel 5.0+ (5.11+ for certain fns) just to be safe. Didn't test it on anything older.
A true final note is that this isn't really as polished or professional as glibc _yet_. I'm still working on ironing out any defects, the library is generally stable but you _might_ run into edge case issues especially around cross-arch code or the less tested paths.
source: https://github.com/rfgplk/micron.cpp
Happy to answer questions about any of the internals. Thanks!

value: Show HN: Micron: a high performance C++23 (re)implementation of Libc and the STL

author: rfgplk


value: oleksiijko

value: PMB is a local-first memory system for AI coding agents, running on MCP and storing data with SQLite and LanceDB. It preserves project context, decisions, and preferences across sessions and tools. I created it because coding agents frequently lose valuable context between sessions, especially on long projects. So, I'd love feedback from those who use coding agents regularly. What do you think should be auto-remembered versus what should always need explicit confirmation?

value: Show HN: PMB – Local-first memory for AI coding agents

author: oleksiijko


value: marshalla

value:
I’ve spent the last seven months building a tool I wish I’d had in my previous roles. MimicScribe is a macOS menu bar app that fits the "AI notetaker" category. It has accurate on-device speaker identification (a first possibly?), real-time meeting talking points for discovery calls, and a fully keyboard- and voice-driven interface.
I believe the accuracy of the speaker ID system is its biggest strength. I used fluid audio’s port of (https://github.com/fluidInference/FluidAudio) Pyannote's community-1 as a base. To improve accuracy, the system uses grammar structure cues from the Parakeet STT to mask by sentence. By taking a second set of samples within that mask for cluster assignment, it leverages the fact that most people don’t finish each other's… sandwiches in business meetings. It tends to slightly oversegment, as I’ve found it much easier to merge segments or reassign a speaker than it is to untangle an incorrect merge. https://github.com/MimicScribe/benchmarks/blob/main/diarizat...
The app provides in-meeting talking points using a prompt tuned for discovery type calls. It can suggest probing questions to help you extract more detail or helps you refocus on the big picture with “magic wand” type questions (e.g. “how would your ideal system work”). Getting low latency models to provide novel, relevant, and totally not hallucinated information is a bit of a reach and it tends to restate the transcript frequently but little gems do come from it sometimes so it’s best to think of it as a source of inspiration and be a vigilant gatekeeper.
It’s set up so recording can be started and ended via holding a keyboard shortcut instead of connecting to your calendar service. I prefer this for privacy and to keep transcript history from getting cluttered. Tapping the shortcut shows and hides an always-on-top overlay on your active screen regardless of whether you have other apps full-screen or not. Beyond simple navigation, you can also use voice commands to make post-meeting corrections or additions, for instance, you can simply say "merge this speaker with that speaker" to clean up the transcript.
It also has push-to-talk/dictate functionality with LLM cleanup - what the app started as but that tool was developer catnip, soo many of them.
A developer friend who’s worked in finance reviewed the site and said he’d bounce because the privacy story wasn’t strong enough so I added a completely on-device mode and a bring-your-own-key option. Using cloud models does add a lot to the experience, including context aware speaker merging and fragment cleanup, summary items during meetings, action items attributed, etc. On-device mode is completely free and the speaker identification is still very useful.
The privacy story is my biggest worry with the app, particularly since its target audience is more technical people. I’d love to get people's thoughts on it and any feedback would be super helpful.

value: Show HN: On-device transcriber that's 97% accurate at identifying speakers

author: marshalla


value: rankiwiki

value: Show HN: Fooglemap – a map for local restaurant discovery

author: rankiwiki


value: Show HN: Audit any AI/data pairing with Veritrooper


value: MCP server for managing email archives stored as .eml files. Designed to work alongside a pair of Power Automate flows that automatically export Outlook emails to OneDrive as .eml files, giving AI assistants full read and write access to your inbox, sent items, and drafts through a structured set of tools.

value: Show HN: Interact with your .eml files using MCP tools


value: BuddhaSource

value: Show HN: Crowdsource agents for reasoning, reward top. A live Experiment

author: BuddhaSource


value: felixrieseberg

value: Show HN: Relic, a tiny coding agent for ancient and constrained systems

author: felixrieseberg


value:
I have been interested in long-horizon coding tasks for a while, especially with benchmarks like FrontierSWE, where even the best coding agents like Codex and Claude Code struggle to complete tasks.
These agents come with a collection of tools like bash, file edits, grep, glob, etc.
Lazarus takes a different approach. The idea is to give the model exactly one tool: a persistent Python runtime.
Model writes Python code, executes it, and receives stdout/stderr. Through Python it inspects repos, reads and edits files, runs builds, executes tests, invokes linters, even build custom harnesses and automate whatever workflows it needs.
The motivation for this was:
- Tool selection itself is a planning problem.
- Specialized tools are often difficult to compose together efficiently.
- Long-horizon tasks frequently require custom workflows that predefined tools don't provide.
- Python is expressive enough for the model to build those workflows itself.
Another decision is avoid agent hierarchies. Lazarus runs a single tool-calling loop rather than managers, planners, and worker agents.
The intuition being current models are much better at writing code than coordinating fleets of agents. Agent orchestration consumes context, introduces extra modes of failure, and adds complexity.
How does Lazarus manage context? When the "usable" context window of a model is nearly exhausted, the model gets one final opportunity to execute a Python tool call, containing anything it wants to preserve: notes, plans, functions, summaries, partial results, etc.
The loop is then restarted with only:
- The original user task
- The carryover cell
- The carryover cell's output
This allows the agent to periodically compress its own state and continue working without requiring an ever-growing context window.
I evaluated Lazarus on two FrontierSWE tasks:
- git-to-zig (rewriting git in zig)
- dart-style-haskell (rewriting dart-style formatter in haskell)
The runs with scores are available here: https://github.com/ExpressGradient/frontier-swe-lazarus-runs
Using GPT-5.5 at medium reasoning effort, Lazarus achieved scores comparable to reported GPT-5.5 in Codex with xhigh reasoning.
The runs were not completed to exhaustion, I stopped them because I ran out of OpenAI credits. So I suspect there is still room for improvement from longer runtimes and higher reasoning.
The project is still early, but the results made me wonder whether coding agents have become over-specialized around tool collections and orchestration systems, while under-investing in giving models a programmable environment they can shape themselves.
Lazarus: https://github.com/ExpressGradient/lazarus

value: Show HN: Lazarus, a coding agent for long-horizon tasks


value: jrpt

value: Show HN: SupXML, modern memory-safe XML parser replacement for libxml2

author: jrpt


value:
I have been working on multiple projects lately involving AI endpoints (including some I run locally) and I found I needed a way to easily load balance across multiple. Sometimes my on-prem would not be able to handle to load and Id have to crank up the z.ai usage or Anthropic depending on where my credits were at the time.
One thing led to another and I ended up writing Busbar: An LLM gateway, written in Rust (I have a thing for Rust lately). You point your existing OpenAI/Anthropic/Gemini SDK at it, change the model to a pool name, and that name now load-balances across the vendors. Your client code doesn't change and never learns it even happened.
My central idea is "protocols, not providers". I implement six protocols - Anthropic, OpenAI, Gemini, Bedrock, Responses, Cohere -  losslessly. You define a provider in three lines of YAML, mainly specifying the protocol that provider speaks.
Your client speaks a protocol in to Busbar and Busbar speaks a protocol out to the provider.
- Each protocol translates request and response, streamed and buffered, in both directions. Same-protocol calls pass through untouched; cross-protocol calls reconcile the awkwardness (a field one dialect requires and another makes optional).
- A circuit breaker that knows whose fault a failure is. It stops routing to a backend that's genuinely failing, but it won't penalize a model for a request that was simply too big (it retries on a larger-context model instead), and it won't blame a backend when the caller sent a bad request. A healthy model never gets pulled from rotation for something that wasn't its fault. All issues I have personally faced and wanted to fix one time in busbar vs 10x in 10 applications.
- Hand-rolled AWS implementations so I am not reliant on AWS SDK's: SigV4 and a from-scratch AWS eventstream frame decoder for Bedrock
It's 1.0.0-rc.2 — feature-complete and API-stable, with release-candidate validation underway before 1.0.0. I have been using it on my projects and its solving my problems nicely.
Solo project, AGPL-3.0. The AGPL choice is open to discussion; I know it matters for a request-path component.
Feedback very welcome, particularly on where the translation might still be lossy in edge cases. Contribution and conversation desired!

value: Show HN: Busbar – every LLM behind one URL, in a single Rust binary


value: gmlion

value:
Hi,
I built TuringLLM to see how far we could go with a universal execution model totally controlled by an LLM.
The basic idea: use the LLM for the step function of a Turing machine. State and instructions are MD files (STATE.md and INSTRUCTIONS.md, respectively). They represent the "modifiable tape" of the Turing machine. Each cycle, the LLM read the state and finds the corresponding instruction to execute. Instructions (and conditions) are written as free-text and, together with state, can be written by the LLM itself during execution.
The scope of each cycle is controlled - each LLM invocation only receives STATE and INSTRUCTIONS. On top of it, a call-stack mechanism provides hierarchical invocation of subroutines with argument passing and return values. This can be used to implement freely multi-agents patterns and also meta-frameworks.
To test its "universality", I implemented 14 patterns from the MAS literature, including Tree of Thoughts, LATS, Meta got, ADAS. They share common operatore when possible. is part is still very much a WIP and may be a bit rough around the edges, so feel free to peek and suggest improvements - but I can confirm it's easy to implement and see a new pattern run in no time; all it takes is some prompting to build the INTERPRETER.md.
There's also a visualizer that renders the cycles and the subroutines as a graph or each cycle as a log of the machine's state.
Let me know what you think, especially if you're working on agents or MAS research.

value: Show HN: TuringLLM – a LLM-powered Universal Turing machine

author: gmlion


value:
Hi HN,
I built a Bash runtime for AWS Lambda to make writing glue code simpler and faster. Sometimes, all you need is a bit of `sed`, `awk`, maybe a loop and a few HTTP API calls, and this runtime gives you all the tools to do that. It comes bundled with `jq` and `curl` so you can handle JSON payloads and string together HTTP API calls right out of the box, including calling AWS services with `curl --aws-sigv4`.
In keeping with the theme, the Lambda handler contract is also made as simple as practical: read from stdin, write to stdout, return 0 for success and non-0 for error. You can run shell scripts, call binaries (either what's available in `al2023.provided` or you can package your own static binaries with your handler), or a combination of both.  If you remember nodding along to Adam Drake's post about how bash and coreutils can be faster than a Hadoop cluster, I hope you give this a whirl and find it useful. The runtime is packaged as a Lambda layer, so it should drop right into your normal AWS infrastructure.

value: Show HN: Bash Runtime for AWS Lambda

title: Show HN: Bash Runtime for AWS Lambda


value: abstractcontrol

value: I made this replay simulator desktop app as a part of the Building The Trading Edge playlist on Youtube. It's my first commercial product. I needed a replay simulator that could do full tick-by-tick order book replay on US equities and when I couldn't find any, I made my own in F#.<p>If any of you ever wanted to learn to daytrade stocks, use this to practice before risking any money first.

value: Show HN: TapeSim – Practice Reading the Tape

author: abstractcontrol


value: Floppyrom

value: Show HN: A backwards dough fermentation scheduler

author: Floppyrom


value: cebceb

value: Show HN: I rebuilt a tiny old volleyball game I loved

author: cebceb


value: Show HN: OWASP VulnerableApp Modern Extensible and Scalable vulnerable app


value: winchxyz

value: Show HN: Idea-to-build – a workflow that challenges ideas before building

author: winchxyz


value: OlegIvanov

value: Show HN: Fluenta – validate a business idea against 6 live demand signals

author: OlegIvanov


value: aaronestrada

value:
This is an upgrade of a tool I created 15 years ago in Python to learn OOP and solve some inadequacies in the HDR stacking tools I could find at the time. The problem was, none of them were really "batch friendly". None of them properly preserved the metadata I wanted them to stuff into the output file. There were probably some other reasons also, I just can't remember them now.
It got the job done, but was very slow. Python was what I knew at the time and even with NumPy, I was limited in the speed I could squeeze out of it. (I also made some very specific, conscious, architectural choices to be extra frugal with RAM, which impacted performance further.)
This new version is SUBSTANTIALLY faster than the old one. This time around the exercise was more about having some fun in Lisp using an AI agent REPL skill I created and exploring SIMD in SBCL via the built-in sb-simd library.
It uses LibRaw (via its C API wrapper and CFFI) for reading and and a custom multi-threaded pure Lisp implementation of (a subset) of OpenEXR I created for writing the output files. The threading helps speed up the otherwise expensive deflate based codec and goes a long way towards speeding up the end-to-end pipeline. The core processing / compositing logic is pure Lisp.
Cool features:
* Buffer parallel (threaded) LibRaw reads
* Frugal use of memory (RAW read as 16 bit INT and is only upcast to float during actual stacking)
* AVX2 acceleration of 16 bit INT up-cast and HDR stacking loop
* Threaded OpenEXR writes
* EXIF to EXR metadata preservation of the "center" exposure bracket, which essentially forwards meaningful telemetry regarding the radiometric "reality" of the scene when it was photographed downstream to subsequent consumers.
You can learn more about it and the "algorithm" it uses from the repo. The math for HDR stacking is really very simply if you know basic compositing and understand how digital camera sensors work.

value: Show HN: I created a RAW to HDRI stacker in (mostly) Common Lisp

author: aaronestrada


value:
Hi HN, I’m Aseem
Last month, during my commencement for a Master's in Privacy Engineering at CMU, my friends and I were joking about the absurd volume of unreadable privacy policies we’d spent semesters dissecting. What started as a graduation joke stuck with me, and over the last few weeks, it transformed into this actual project.
I’m personally very privacy-conscious—I self-host my NAS, run Immich for my photos, and try to self-host where I can. But completely decoupling from third-party services is nearly impossible. Even with a technical background in privacy and security, figuring out what a SaaS tool actually does with your data telemetry means wading through buried boilerplate that no one has time to read.
I built HonestPrivacyPolicies.org to turn that text into structured, actionable insights.
Would love your feedback. A few questions I've been asking ppl :
1. What would you love to see in a privacy policy (check our pp as well)
2. What questions do you want answers to when you give your data to an org
Cheers!

value: Show HN: Honest Privacy Policies – We Read the Fine Print So You Don't Have To


value: cosmtrek

value: Show HN: Jeju – a local-first agent harness with inspectable runs

author: cosmtrek


value: odig

value: I was annoyed because I couldn't find an online VNC client at all, let alone one that proxies it without an account, so I made this over a couple hours.

value: Show HN: Private in-browser VNC client with CF Workers

author: odig


value: noahfradin

value:
Tl;dr: I trained a classifier to route to the least expensive model and reasoning depth to complete the request. Coupling that with additional automated token efficiency techniques has yielded 3x usage for the same spend.  For anyone interested in trying it themselves: https://nerfguard.com
Various teammates and I switched over to Codex from Claude Code recently. We still bounce between the tools, but Codex’s speed and steerability coupled with performance gains were hard to ignore. One of the downsides was that the per token pricing kicked in way sooner. This is happening across the board, but we felt it in Codex more acutely. We’re a startup filled with people who work around the clock and are obsessed with building — naturally our daily bill alone was striking.
Luckily we’re going after a big mission and speed matters significantly more than marginal token spend on the edges. Still, it got us thinking about how it was ludicrous that while our product has a side effect of decreasing token spend and speeding up agentic workflows by many orders of magnitude, we were using these top tier models for all types of internal coding tasks without any of those optimizations. The waste felt pretty ridiculous — the most glaring culprit was that we were seemingly using the max intelligence model on max reasoning for every task even when the task clearly didn’t require it. As a company who spends a lot of time on cached intelligence, it was also easy for us to see how there was plenty of other low hanging fruit as well.
So, on a recent weekend, I quickly built a tool to optimize our usage. At its core is a very fast classifier that classifies your requests to the least intelligence required for the task and includes some nice token optimizations on top. The result is roughly the same quality for multiples lower token spend. But even more exciting for us, is that the properly bin packed intelligence and reasoning levels meant our speed also went up considerably. This wasn’t negligible.
We’ve observed up to 3x savings and hours per day per person in saved time that we would have otherwise been waiting on tool turns and coding agent responses.
For us, that means improved engineering velocity and significantly higher usage for the same spend. It also means more usage before getting throttled.
As I told friends about this, they also wanted to start using it to maximize the usage they could get out of their coding agent plans. There are now engineers across many of the most cutting edge AI companies using this tool to optimize their token utilization in this way. Not just to save money, but to maximize output. Turns out that the best way to avoid getting nerfed by Claude is to intentionally nerf yourself selectively. We decided to release it for the rest of the builder community to use as well. You can now turn on Nerfguard for yourself and start getting more usage today.

value: Show HN: I nerfed our coding agents on purpose

author: noahfradin


value:
Finally made something I've always wanted, using the model we built.<p>• SOTA omni embedding model, fully local, indexes text, PDF, image, audio, and video
• Swift-native app UI + mlx-swift-transformer core. No Python.
• Tested on M3 Pro 18G / M3 Ultra 512G / M4 Pro 48G. All work fine.
• HTTP server exposes search to local agents like OpenClaw & Hermes
− Indexing still feels slow even on the latest M3 Ultra, ranging from 10K tps to 300 tps depending on file type
− Fans go crazy, high power draw while indexing
− Search is near-instant. Multimodal relevance is sometimes arguable, but the idea is recall (the agentic LLM takes the results and refines for the final answer), so maybe that's fine

value: Show HN: Omni – Local-first multimodal file search on macOS


value: dcdgo

value:
I created a custom compilation error and Unit Test Runner for BDD Cucumber Specifications in Gherkin Syntax. Both C# and Rust are supported using Source Generators and Procedural Macros.
If there is a line mismatch in a test, the build will fail before the tests do. This is useful if you like the idea of unit tests but don't appreciate the amount of boilerplate and iteration time libraries such as XUnit require.
Try it in your agentic workflow and drop a comment with any feedback. Hopefully it will help you all reduce documentation drift and LLM hallucinations.

value: Show HN: Simple attributes for spec-driven agentic workflows (C#, Rust)

author: dcdgo


value:
Hi HN, I am building Adamas VR, a TypeScript SDK and runtime for building multi-user VR projects.
The motivation for this project is that the traditional game-engine based VR development workflow often requires developers to rebuild the common VR infrastructure. To reduce the overhead of VR development, I wrapped the common VR subsystems, such as avatar, locomotion, and multiplayer, directly into the runtime environment, so that developers can only focus on the application logic instead of rebuilding the same infra.
One interesting design choice I made was that: VR projects are treated as regular node packages that run on Node.js, and they are fully compatible with the npm ecosystem.
If you are interested in this, please give me a star on Github, and/or join my Discord, which is in the readme of the github repo.
Also any feedback is appreciated!

value: Show HN: Alternative to WebXR, TypeScript SDK for multi-user VR app development


value: nolanfogarty

value:
Hi HN, I made this after seeing a few similar projects on the front page. NBA API endpoints are public and there’s a pretty robust python package ( https://github.com/swar/nba_api  ) that I referenced for the endpoint structure to build an sdk in go. used BubbleTea and LipGloss for styling. It was a bit tricky to test the live endpoints but I watched Friday’s Final game with this and it worked pretty well
playball - https://news.ycombinator.com/item?id=45451577
faceoff -  https://news.ycombinator.com/item?id=47826104

value: Show HN: Courtside – TUI for NBA Games

author: nolanfogarty

title: Show HN: Courtside – TUI for NBA Games


value: TylerJaacks

value: I have been using Claude for the past couple of days this week to document and modify the TR2 game file format for an obscure Japanese-exclusive Wii game called And-Kensaku, or 安藤ケンサク. And-Kensaku is a game related to Googling. There are a few game modes, but the most famous one asks you a question and gives you two answer options, and you win if you choose the most popular Google search. I have been able to do the following: 1. disable signature checks on the files, and 2. allow edits to the Phrases.tr2 file, making it possible to modify the content of the aforementioned game mode. I wanted to go on this little adventure because reverse-engineering file formats is an extremely difficult (at least for me) and time-consuming task, and I wondered how well Claude would do at it. Right now, not everything about this game is documented, but I would like to fully document it and maybe release an English patch.

value: Show HN: Documenting an Obscure Japanese Wii Game – and-Kensaku

author: TylerJaacks


value: lanchuske

value: Show HN: Local MCP – give Claude, Cursor and ChatGPT access to your whole Mac

author: lanchuske


value:
So my dad has been running a small print shop for the last 20+ years. He mainly works with brokers and wholesale but was never able to tap into the retail scene.
Helped him build this AI business card generator that will hopefully drive more retail business to his shop.
Just paste a website url and you get a double-sided on-brand business card in a few minutes. Shipping and printing is handled by our family print shop in  LA.
Thoughts and feedback welcome!

value: Show HN: Turn your landing page into print-ready business cards


value: gotski

value:
This weekend is the ABC Classic FM countdown, which prompted me to dust off an old un-published data visualisation of rankings from previous years.
I've considered adding a search function, but I also kind of like that it requires a bit of exploration in the current form.
Some of the code is a bit clunky and I wouldn't mind refactoring it. I'm also not sure about browser compatibility - I've only got access to a couple of devices to test it on.

value: Show HN: ABC Classic 100 Rankings visualised

author: gotski


value: egeozgul

value: Built an incremental Structure from Motion pipeline that reconstructs a sparse 3D point cloud from a sequence of images. Used Kız Kulesi (Maiden's Tower) in Istanbul as the demo dataset. Interactive 3D viewer included.

value: Show HN: Incremental SfM pipeline that reconstructs 3D point clouds from images

author: egeozgul


value: skeptrune

value: Show HN: Declank – Remove AI Watermarks from Images

author: skeptrune


value: cheikhshift

value: Show HN: Lite Agent redefines what an AI agent is

author: cheikhshift


value: Show HN: The Deterministic Core Architecture for AI-Augmented Applications


value: luwo

value: Show HN: Apple Contacts MCP – Local AI Access to macOS Contacts

author: luwo


value: tanlethanh

value:
Hi everyone! I want to share my recent work, Zedra. This is a mobile code editor that connects directly to your desktop. It's like Claude/Codex remote control, except you can run any AI coding agent via remote terminal, with code editor, markdown, file browser, git view,... A true code editor on mobile.
It's built on Rust with GPUI, leveraging the high-performance rendering engine that powers Zed editor, now on mobile with Zedra. The connection is peer-to-peer using outbound-only networking, on QUIC/UDP, working on home networks, without port forwarding.
After 4 months of intensive work, Zedra is now ready to try on iOS/Android, CLI supports Mac/Linux/Windows.
https://github.com/tanlethanh/zedra

value: Show HN: Zedra – Mobile control plane for AI coding agents

author: tanlethanh


value: Show HN: Backup Your Perplexity Research to Markdown and Obsidian


value: LBWasserman

value: Show HN: NEP – Ethereum JSON-RPC transform that beats ZSTD by 12%

author: LBWasserman


value: yapancha

value: Show HN: Nimbril – 12 file tools that never upload (airplane-mode test)

author: yapancha


value: codesoda

value: Paxel looks like a great way to score a Startup School ticket, but check what it does with your code before you upload.

value: Show HN: What does YC Paxel do with your source code?

author: codesoda


value: Show HN: Nanocode-CLI – A lightweight terminal-based AI coding assistant


value: julienreszka

value:
We added tooling to our chat to make it agentic.
It can control our 40+ apps suite.
One of the tools is url fetching with pagination.

value: Show HN: Summarize YT Video by pasting url into AI chat[video]

author: julienreszka


value: patriceckhart

value: Show HN: Sidekick – The zot coding agent, one click away on macOS

author: patriceckhart


value: fgdhtt

value: This is an attempt to calculate tech dependency towards countries and brands based on different services and devices you use.

value: Show HN: Tech Dependency Calculator

author: fgdhtt

title: Show HN: Tech Dependency Calculator


value: radotsvetkov

value: Show HN: Akmon, verify what an AI agent did offline using only OpenSSL

author: radotsvetkov


value: undolog

value: Show HN: Netfox – A native macOS network monitor built in SwiftUI

author: undolog


value: Show HN: Find any type of event visualized on a map


value: ssarisen

value:
I built an open source bookmark manager for X (Twitter).
Features:
- Search bookmarks
- Tag bookmarks
- Organize saved content
- Self-hostable
GitHub:
https://github.com/sarisen/x-bookmark-manager

value: Show HN: Open-source X Bookmark Manager

author: ssarisen

title: Show HN: Open-source X Bookmark Manager


value: ayranlahmacun

value: Show HN: I used to pin street parking by hand in Google Maps. Now it's an app

author: ayranlahmacun


value: avestura

value: Show HN: Sub-Agent MCP: LLM delegation and sub-agent orchestration via MCP

author: avestura


value: Show HN: Hackspot.dev – Winning hackathon ideas in 30 seconds


value: Hi everyone! I’d like to share my first Android app, a client for Hacker News. I have been a dev for 8 years but I am just starting my journey into making mobile apps. Since this is my first app, I’m sure there’s plenty of room for improvement, so I’d really appreciate any feedback, suggestions, or ideas.

value: Show HN: NullRead – A simple HN Android client


value: timurg

value: Show HN: Sugi Atlas – 52K+ deterministic gene/drug/disease reference pages

author: timurg


value:
Hi HN,
I built an AI-powered OCR API designed to extract highly structured JSON data from complex documents like global passports, IDs, receipts, and shipping containers. We recently rolled out our Python and Node.js SDKs.
Just wanted to share it with the community.

value: Show HN: StructOCR – API for parsing global passports, invoices, and containers


value: samidurbar

value: Show HN: Facebook cover photo resizer that shows the mobile crop before upload

author: samidurbar


value: sheremetyev

value: Show HN: Minimal native macOS sandbox for Claude and Codex

author: sheremetyev


value: Sparckix

value: Show HN: An adversarial reasoning engine for scientific progress

author: Sparckix


value: CzaxTanmay

value: Show HN: Proton – A CGO-free immediate-mode GUI framework for Go

author: CzaxTanmay


value: flippant

value: Show HN: MemoryHole – Personal Internet Archive

author: flippant


value: unlike regular teleprompters cuenotch stays right below your camera and the teleprompter scrolls with your voice where you read your script while making eye contact. Cuenotch also has an rehearsal mode where you can rehearse your script with your camera on and our rehearsal coach gives you useful feedback on things like the pace of reading ( slowing down , pausing ) to make your presentation more engaging.

value: Show HN: Native Mac app which places an teleprompter in your Mac's notch


value: yazon

value: Show HN: Oh my wrist – Garmin alerts for Claude Code and OpenCode

author: yazon


value: scrollaway

value:
My team uses Claude Code daily, and the sessions have become some of the most useful artifacts we produce. But they're trapped in ~/.claude/projects/ on whichever laptop they happened on. There's no good way to hand a colleague "the session where I untangled the migration" so they can claude --resume it and keep going from where I left off.
Enter ccgs: Share Claude Code sessions through an orphan branch (@ccgs/<name>) in your existing repo's remote
- Session files carry the author's absolute paths. On pull, ccgs rewrites the working dir back to your path so resume actually works — surgically editing only the structural cwd field, not a blind find-and-replace that would happily corrupt the transcript.
- Everything goes through git plumbing (hash-object/commit-tree/update-ref) against a throwaway index. It never touches your working tree, index, or current branch, and it's fine with a dirty tree. It will not git checkout something behind your back.
To try it without installing: `npx claude-git-sessions`. This also incidentally allows you to move a directory and carry the claude code transcripts with it (just push first, then move the directory, then pull)
IMPORTANT CAVEAT: Unless you have a very good security hygiene, your Claude Code sessions are likely full of sensitive information such as environment secrets. Use with caution and avoid using on public repositories. Branches used by ccgs are prefixed by `@ccgs/` so you can easily filter them out.
This project was written by and with Claude Code. This Show HN was not.
(Reposted with URL fixed)

value: Show HN: Ccgs – Collaborative Claude Code sessions, stored in Git branches

author: scrollaway


value: julienreszka

value: Show HN: How to do outpainting (canvas expansion) on an image [video]


value: remarketme

value: Show HN: Founder VC Horror Stories

author: remarketme

title: Show HN: Founder VC Horror Stories


value: Show HN: Change multiple parts of an image at once with annotations tool[video]

author: julienreszka


value: Show HN: Markdown Notes with Chat and Mail


value: Show HN: Yet another website for learning Go / WeiQi / Baduk


value: jojule

value: I believe the fastest way to learn your way to product–market fit is to have conversations. Conferences are great, but expensive and infrequent. Website chat could fill the gap, but most tools are optimized for support and lead capture rather than learning. I built Stand Chat as a tool for getting some of that “expo stand” experience online: https://stand.chat/

value: Show HN: Website chat for product discovery instead of support

author: jojule


value: arjf

value:
Last April I shared about my Resonate project here (https://news.ycombinator.com/item?id=43694157)
A lot has happened since: the work I presented in much more detail at last June's International Computer Music Conference (ICMC) got best paper award. I also gave a talk at the Audio Developer Conference in Bristol last November, the video is on YouTube).
This year's work, which I recently presented at this year's ICMC, starts with known techniques from the phase vocoder literature to build self-tuning filter banks that extract very efficiently the frequency components that are actually present in the input signal. Overview on the project website, more details in the papers, including applications to super-resolution spectrograms and re-synthesis experiments.
As many people have pointed out, none of the techniques I have used are new (some of them even have different names across different fields), but I haven't seen them applied together in this way, and to me the results are incredibly satisfying and sometimes look magical. See for example this demo: https://youtu.be/LasdoIJJkw8
Of course the best way to experience in person is through the free demo app: https://alexandrefrancois.org/Oscillators
Looking forward to feedback from the community!

value: Show HN: Resonate – Low-latency, high-resolution spectral analysis

author: arjf


value: Show HN: Competitive Programmer's Web Debugger


value: Show HN: CCC: One place to manage all your Claude, Codex, Antigravity sessions


value: w-martin

value: Show HN: Typedframes – Pandas/polars column name checking at lint time

author: w-martin


value: One agent. Every model. Zero limits

value: Show HN: Kodiqa Agent

story_text: One agent. Every model. Zero limits

title: Show HN: Kodiqa Agent


value:
I like Hammermade shirts but not the price, especially since they go on sale for 50% off on occasion.  I also don't like being a product, pop up ads that feel like a minefield, and being directed instead of receiving a service.  So I made a simple notification app that the I can drop a product url into, have it find the price, and let me know when it drops or reaches a number I want to pay.  If the retailer requires a premium scraping service, the app escalates to that level.  The user can opt in or out of paying for that from a prepaid bank of money.  They know how much the premium service will cost and how long they can watch the price for a given amount.  I tried to keep it very simple and user focused.  I will probably add SNS to the email notification, but only once users start asking.  It's a free 7 day trial, should be really easy to sign up (I would appreciate feedback on the sign up process), and I think it's pretty sweet.  Saved my wife a few bucks on geraniums from Gertens and on some loose leaf tea.
I will never put ads on it or sell user data.
Let me know what you would do differently, Thanks!
Brian

value: Show HN: PriceHound.app – Price tracking for $1/mo instead of selling your data


value: YesJustWolf

value:
I have been coding over four decades, in many languages, on many projects (including Firefox, Final Cut Pro, the Newton, and Fullwrite Professional if you can remember that far back; all these using my "dead-name").
I wrote something small and simple to scratch an itch. It's the UNIX philosophy: small "one-trick ponies", each *really* good at their one trick, then the user can hook them together to solve actual problems. I'm a CLI guy, and for almost everything, I already have this. But not for debugging. The itch I scratched was the connector that enables this philosophy for debugging. That thing is dap-mux. A DAP multiplexer turning a one-to-one protocol into a cooperating session of as many tools as you need to get it done!
How it started: Helix and Python for me (and sometimes IPython), with the rest of my team using PyCharm (which I have long loved!). My team's problem is that they want the PyCharm debugger, and so must be satisfied with the JetBrains editor. *My* problem was I could use a full-blown debugger *or* I could have IPython *or* I could have Helix (or sometimes an unsatisfying combination of Helix and the debugger). That was my "itch".
DAP (Debug Adapter Protocol) is the tantalizing answer, except it isn't. DAP is what editors (that don't want to write their own debuggers) are starting to adopt. The problem with DAP is it's one-to-one. One editor connects to one debugger. Done. Not a solution to my problem. And then suddenly, it *was* the solution. I realized that a DAP multiplexer would let you connect any DAP-aware editor to any debugger for any language, and simultaneously to a REPL, another session of your editor (or a different editor)! With the side benefit that now, like screen or tmux, since each process is its own thing: sessions are durable. Just restart whatever crashed and you're back where you were!
There were hard parts: sequencing, late joiners, state management. Different end-points working on different actions in different sequences but with the same message ids. I solved these problems something like how NAT works. Instead of translating network addresses, though, I'm translating the sequence numbers of each client into something global and ordered, then correctly routing replies back to the end-point awaiting them, while mapping the sequence numbers for those replies back into the space of that end-point. Knowing the current state of the debugger, and replaying that as a message sequence to late joiners lets you start/connect the clients in any order. I chose Python: asyncio fits the I/O-router pattern perfectly, and it lets the IPython extension run in-process rather than over IPC.
There are problems not yet solved: for instance, I think configuration in the clients and/or the startup sequence is too complicated. But it functions! I got what I wanted!
The combination I use every day: Python + debugpy + Helix + IPython, all connected simultaneously. Step with `%n` or `%s`, evaluate expressions with `%eval`, watch Helix track the current line in real time. Rust with codelldb is the second confirmed combination — I debugged a Dijkstra implementation with Helix and a third-party DAP observer tool both connected to the same codelldb session. A community member, Sean Perry, has already built [dap-observer](https://github.com/shaleh/dap-observer), which renders the current frame's variables as a navigable terminal tree. *This* was my exact dream! Small, focused, connectable tools all playing together!
There's so much left to try: other editors, other debug adapters, Windows, other languages. None of this has been touched yet. The most helpful thing now is people testing it with their own setup and reporting what they find. It's time to play!
`uv tool install 'dap-mux[ipython]'` for Python + IPython. `uv tool install dap-mux` for headless use with any language and adapter. No need for any part of the Python ecosystem.
https://github.com/dap-mux/dap-mux

value: Show HN: Dap-mux – Connect your editor and REPL to the same debug session

author: YesJustWolf


value: conchaestrada

value: Show HN: Aegis – post-quantum cyberdefense proxy (471 attacks, 0 breaches)

author: conchaestrada


value: dfskGT

value:
Hi HN,
I built a simple, single-purpose iOS utility: a bubble level that lets you calibrate out the physical angle offset caused by iPhone camera bumps and cases. It automatically switch between 3 modes when you try to use it on the back, along the long edge, or along the short edge.
The Problem with the iPhone's Measure app and other Bubble Level apps:
If you lay a modern iPhone flat on its back to see if a surface is level, the camera bump (and the shape of the phone case) tilts the device by a degree or two. Existing apps do not offer a correct way to calibrate this physical offset away, and are often annoys you with Ads, paywall, etc. Their so called calibration allow you to click a button to set the reading to zero, but when you rotate your phone on the same flat surface, it won't be zero anymore. The correct calibrated reading should be zero no matter how you place the phone.
The Solution:
I wanted a clean tool that solves this specific issue. To use it, you place your phone on a known flat surface, tap "Zero" and follow the instruction to simply rotate your phone a few times. Now you can use your iPhone as a leveler as if it has a flat case.
A Few Details:
- Free: The calibration feature is free to use, a one time payment of $1.99 to enable sub-digit reading and haptic/sound feedback.
- Privacy: The app collects zero user data and requires no sign-ups or network permissions.
- UI: It is designed to be minimal and lightweight, focusing only on the utility of leveling.
The app is free to download: https://apps.apple.com/us/app/id6767735397
I would appreciate your feedback on the usability, the calibration flow, or any additional utility features you think would be useful to add.
Thanks!

value: Show HN: An iOS bubble level designed to calibrate away camera bump

author: dfskGT


value: oleksg

value:
Recently, I found myself having to read the book "C++ primer" and I just couldn't do it. Maybe my attention span is too little now with Claude and Codex, maybe I'm lazy... but I just couldn't get myself to focus.
While reading, I needed something to do. I wanted to talk to the text, I wanted to leave notes, I wanted to use to use my keyboard to quickly flip through pages.
The only good available option on a Mac was "Preview" and it was ok, but definitely not there. So I built Quincy primarily for myself.
With it you can
- "Talk" to the page you're reading, create a quiz about the page, and get a good summary
- "Read" the page out-loud. Have your Mac read to you while you follow along. This helps with comprehension.
- Copy text (to paste into an LLM), leave notes, bookmarks, etc....
- Anything else you'd want with a nice PDF reader
It's fully local. No cloud-sync (yet). All LLM calls are based on your keys. And TBH, you don't even need to use the AI features for this to be useful.
Try it out. Let me know what you guys think. This has been a quick project, so very rough around the edges. I plan on keeping it going (still haven't finished my book), and potentially open-sourcing down the line.

value: Show HN: A beautiful and local-first PDF reader for studying dense things

author: oleksg


value: alexpadula

value: I've been working with storage engines for quite a while and really there was no similar tool to sysbench and or HammerDB for key-value storage engines.  Thus I introduce a POC called keybench.  I hope you check it out, and do give it a run to drive your favorite engine.<p>Cheers!

value: Show HN: Keybench – Scriptable, extensible performance tool for key value stores

author: alexpadula


value: Show HN: Aquifer – an MCP runtime for spiky agent tool traffic


value: alpadurza

value: Show HN: Note management app that sorts and files stuff for the user

author: alpadurza


value:
Hi HN,
I have been working on a new programming language and compiler.
Website: https://ironwall-lang.dev
GitHub: https://github.com/3WyUFvDOdCbBw7gOZHwcfgKF/ironwall
Why a new language is still needed:
https://ironwall-lang.dev/en/motivation
The compiler is written in TypeScript at the moment, and work on a self-hosting compiler written in Ironwall is ongoing.
I would be interested in feedback.
Thank you.

value: Show HN: Ironwall, a safety-first native programming language and compiler


value: antileet

value: Show HN: VaultSQL – Open-Source Zero-Trust SQL Workbench

author: antileet


value:
Hi HN,
I am co-founder of Persist AI.
Meet Persist.chat an AI sales agent that follows up to prospects till you secure a sale. It can help you find prospects for your product with our extensive lists of Linkedin and email lists and also you can bring your own list of customers with their email/phone_number,linkedin/x handle It sends a personalized email/text messages with a continuous loop. Our agent can help you launch a campaign with different tasks to different groups of customers.
I personally struggled getting traction and converting customers. I have found myself a better chance using this product as a step foot from 0 to 1 instead of spending 10,000+ on ads that do not target the right audience. The feature of persistent reach out with out it being a spam is the greatest one. You a configure it as a sequence, on every email/text it sends different personalized state aware messages. Front onboarding walking thru potential customers till you secure a sale. Consider it after building your saas product, use our product to get sales.
its open for early access. Opening up early access in batches. it's completely free for early access users. Happy hacking & weekend.
~Persist.chat

value: Show HN: Persist – an AI agent that follows up accrued channels till they reply


value: Show HN: DomainTasker – avoid losing domains and surprise renewals


value: danipolani

value: Recently I've created this free browser-based tool for visual word alignment, interlinear glosses, IPA/RTL text, and exportable bilingual examples.

value: Show HN: Word-by-word translation aligner tool

author: danipolani


value: Show HN: Oproxy – inspect and modify network traffic from the browser


value: eamann

value: Show HN: Ext-Infer – Native LLM Inference and Embeddings for PHP

author: eamann


value: sakuraiben

value: Show HN: TakoVM – Isolated model and tool execution used by enterprises

author: sakuraiben


value: ronreiter

value: Show HN: LLM for Dummies

author: ronreiter

title: Show HN: LLM for Dummies


value: linzhangrun

value: Show HN: Get v2.0

author: linzhangrun

title: Show HN: Get v2.0


value: meaningofdesign

value: Show HN: Wifiland – I turned nearby Wi-Fi network names into a live fantasy map

author: meaningofdesign


value: This is currently a Mock-up right now. and I'm trying to find a users who can give feedback and tell us what they really want to see.

value: Show HN: Z2H market awareness OS for traders


value: antonynjoro

value:
I read Markdown all day, mostly Claude .md, and other AI outputs. Every app I have tried felt janky or too much work to just read an md file. I just wanted to open a .md file and read it the way Preview opens a PDF.
So I built Kite, a Markdown reader for Mac. It has QuickLook just like Preview and I have baked in features that help people reading lot's of AI markdowns.
It one-time purchase, no subscription.
I put it on TestFlight so you can try it before paying anything. I would really like this crowd to try to break it. Tell me which files render wrong,what feels off, what is missing.
TestFlight: https://testflight.apple.com/join/vzw7CRQQ

value: Show HN: Markdown Editor and Reader for Mac

author: antonynjoro


value: givebest

value: Show HN: I built a local motion-event scanner for long camera videos

author: givebest


value:
I created TabyAgent, a lighter and easier-to-use alternative to OpenClaw and Hermes.
It runs exclusively within Docker without requiring host mounts and allows you to chat via Telegram.
I’ve used both OpenClaw and Hermes in the past, but I decided to build this myself because of their instability and, in the case of OpenClaw, its heavy footprint and numerous bugs.
It was intentionally designed to be simple, so it lacks the complex features found in OC or HA—such as support for various messengers, image generation, and voice calls—but I consider this a strength because it makes it easier to maintain and helps keep it lightweight.
As of this writing, version 0.3.1 has been released and is available on GitHub under the AGPL 3.0 license: https://github.com/gpdir16/tabyAgent
While all the features I personally need are already implemented, please let me know if you have any requests for additional features or feedback while using it.
# Key Differences
- Uses approximately 9 times less RAM than OpenClaw (OC ~3GB, HA ~600MB)
- Runs in Docker without host mounting, reducing the risk of host corruption (OC requires host connection, HA requires host connection)
- Interactive and easy setup via a single installation script and the Telegram bot (OC/HA setup is complex)
- Proper table rendering within Telegram (not supported by OC/HA)
- More cost-effective due to relatively lower token usage and call frequency (minimizes background and non-essential calls)
# Supported Features
- Browser Control: Built-in support for browser-use and Playwright
- Recurring Tasks (Cron Jobs): Agents autonomously configure and automatically execute tasks at specific times
- Built-in Skills: Importing school meal plans/schedules, searching for skills, creating skills, etc.
- File and Terminal Tools: Capable of performing nearly any task
- Various Providers: OpenAI, OpenRouter, Synthetic, etc.
- Automatic Memory: Intelligently adds, deletes, or updates context during conversations or when starting new sessions
- Markdown: Supports Telegram API formatting; tables are rendered as images for transmission
- Real-time Status: Model and tool call counts, context window, output status, active tools, elapsed time, etc.
- Infinite Context: Retains recent messages while compressing only old or unimportant ones
- X Posts: Retrieve Twitter posts without an X API key (using FxEmbed)
- And much more
# Supported Platforms
Supported on any platform with Docker.
For macOS and Linux, you can install it with a single line using the automatic installation script. (Windows requires manual installation)

value: Show HN: TabyAgent – A lighter and easier alternative to OpenClaw/Hermes


value: izzzzzi

value: Show HN: agent-asearch – Go CLI, 18 sources, session-based search for AI agents

author: izzzzzi


value: meszmate

value: Coming soon: automated bank statement reconciliation. Right now it's manual entry, but bank feeds are my top priority for the next release.

value: Show HN: Dubbl – open-source accounting for founders and developers

author: meszmate


value: julienreszka

value: Show HN: Cook perfectly with highly precise recipes

author: julienreszka


value: Show HN: SVAHNAR – Serverless infrastructure to run AI agents in isolated VMs


value:
Hello, I'm Hyunbin.
Recently I made 'Rune' which is a small desktop .md writer/editor.
I am aware that there are a lot of .md editor out there. but i wanted to build .md editor by myself.
Major features :
- Atomic Saves (write-temp -> fsync -> rename) so a crash can't corrupt a file, debounced autosave.
- Pasted/dropped images are content-addressed (sha256) into an assets.
- Workspace folder + file tree, Chrome-style tabs
- Interactive task checkboxes, readable/wide width toggle; self-contained HTML and PDF export
- currently supports English/Korean/Chinese/Japanese
Any sort of feedback / contribution is always welcome.

value: Show HN: Rune – A focused Markdown writer for desktop (Tauri/Rust)


value: javatuts

value: Show HN: HN Reader for VS Code with Obsidian Saving

author: javatuts


value: vassilbek

value: Show HN: AI pre-screening CIS counterparties before onboarding

author: vassilbek


value: Lightweight, S3-compatible object storage server with built-in web dashboard. Single binary, low memory, encryption at rest.

value: Show HN: About Lightweight, S3-compatible object storage


value: Cznorth

value: Show HN: WinkTerm – AI that shares the same PTY as you in the terminal

author: Cznorth


value: Show HN: Kyushu – A self-hostable WASM sandbox for JavaScript workers


value: franze

value: Show HN: Bgbgone – local Mac background remover CLI – MIT

author: franze


value: utopman

value:
Hi folks,
I found this setup on consummer hardware that seems to have great results on local hardware.
 - qwen 3.6 q6
 - 450 K context using turboquant turbo3 mode llama.cpp fork
 - multimodal support
This AI generated blog article is a kind of "report" of what and how I did and result exemples.
I hope this can be usefull to some peopole.
Note : I am not much intersted in having success with this article, I mainly want to share what I think is an interesting use of a 5090. I generated the blog page telling AI to be compliant with hn "rules" and remain factual.
It's definitely not perfect, done rather quickly, not properly tested over 265K context. please forgive my lazyness :) . I am just enthousiast right now about what can be done on a 5090.

value: Show HN: Best setup local LLM found for a 5090 (llama.cpp fork + turboquant)

author: utopman


value: SachitRafa

value:
This is a project that I have been building for a while now, YourMemory is a solution to agentic memory which focuses on pruning of noise rather than hoarding of data.
In the current state of agentic memory most of the context is stored in the form of a MD file or is derived through a RAG model where you store each and everything. Both of the solution leads to bloated context which does not optimize the usage of any tokens.
In this system we only keep relevant data in our memory and prune all the unnecessary data. The relevance of a data is derived through multiple factors such as recall rate, importance, category, to which memory chain it's connected to etc. These parameters are fine tuned so that we can cater to both episodic memory and semantic memory.
Our memory layer keeps the size flat in this manner. You can draw correlation of this infrastructure with how Human brain store and prune memory.
The enterprise model is something very exciting as we can extract relevant memories from each user, agent and sub agent in this layer and that can be used by any one in the org, ensuring memory optimization at an enterprise level.

value: Show HN: YourMemory, agentic memory is a pruning problem, not a hoarding problem

author: SachitRafa


value: oboroten

value: Show HN: Grafana Cloud observability plugin for Hermes Agent

author: oboroten


value: Show HN: Fact check, summarize, explain any article or webpage on local CPU


value: bracketview

value: Show HN: BracketView – JSON viewer/formatter/validator in the browser

author: bracketview


value: geoctl

value:
Hello HN , Cordium is a FOSS, self-hosted, general-purpose sandbox platform that I've been working on for a long time now that is built on Kubernetes and Octelium https://github.com/octelium/octelium, my main work. Cordium can be used for various persistent/ephemeral long/short-lived workloads, including coding for developers with VSCode, Zed, etc. (i.e. self-hosted GitHub Codespaces alternative), AI agent tasks (i.e. FOSS alternative to AI sandbox products such as E2B, Daytona, etc.), CI/CD workloads (e.g. building and publishing Docker images etc.), and more importantly for secretless remote access to infrastructure for devs and automated workloads from within the sandboxes.
The key differentiator here for Cordium, in comparison with other dev environments and sandbox platforms, is that Cordium automatically provides identity-based, secretless secure access to resources or infrastructure (e.g. APIs, SSH, databases, k8s, etc.) without having to inject credentials (e.g. API keys/access tokens, SSH private keys, database passwords, etc.) into the sandbox where the upstream credential is held by the identity-aware proxy of the Octelium-protected resource outside the reach of the sandbox. The sandbox permissions and access to resources is determined via identity-based, L7-aware, pre-request access control through CEL/OPA policy-as-code rather than injected credentials inside the sandbox. In other words, Cordium isn't just meant as a runtime for isolated execution where filesystem, CPU, memory, storage, etc... are isolated and controlled, but more importantly meant for identity-based secure access to infrastructure and resources.
In short, Cordium is basically a genereal-purpose sandbox platform + a ZTNA/remote-access-VPN baked-in with unified identity management, L7-aware access control and visibility.
Cordium is a purely FOSS project under Apache 2.0 that's meant for self-hosting and there are no plans for a pro/SaaS/cloud/commercial version. It was developed initially as a remote development environment for Octelium users to access their resources via web-based terminals through reproducible remote sandboxes instead of having to install and run the Octelium CLI connectors on their own machines but over time it grew into a general-purpose sandbox platform that can be used for all kinds of persistent/ephemeral and short/long-lived tasks by developers or automated workloads. I also want to clarify that Cordium, while opensourced a few days ago, is not a new project, the development of the project dates back to 2022 (see the older in https://github.com/octelium/spaces) and it is already being used by a few organizations that use Octelium since last year. In other words, this is not a toy project and it's meant to be used in production even though it's not quite ready to be labeled v1.0 yet. Happy to answer any questions.

value: Show HN: Cordium – FOSS self-hosted sandbox platform alt. Codespaces/E2B/Daytona

author: geoctl


value: devenjarvis

value:
Hey HN!
Lathe is an experiment in using LLMs to teach me something new, instead of doing the work for me. It generates a hands-on, source-backed tutorial for any technical topic you want to learn. Then you work through it yourself by reading and typing the code by hand (gasp) in a local UI built for exactly that.
It's a Go CLI plus LLM agent skills (Claude Code / Cursor / Codex). You prompt something like "/lathe build a 3D slicer in Erlang", run `lathe serve` to spin up a local webapp, and read it in your browser. Every tutorial comes with the things that have made self-learning a pleasant experience for me in the past:
- table of contents that follows along as you scroll
- side-notes that nudge you to think
- exercises for the reader
- sources backing up the content that you can use to take you deeper
To help make up for the lack of human brainpower behind the tutorial, you can also ask questions about the content, have another LLM verify the tutorial actually compiles and runs, or extend it with another part (no more "Part 4 of 6" that hasn't seen an update since 2021).
I didn't build lathe to replace human-written tutorials. I built lathe because I _love_ human-written tutorials, but wanted to learn technical domains where no good human-written tutorial exists yet (building a 3D slicer from scratch, making embedded Zig approachable, etc). There's a longer story in the README about how I got started with programming through PSP homebrew tutorials, and why losing that to LLMs bugged me enough to build this.
I'm not here to sell you anything (there's nothing close to a VC-backed startup here :D). It's an LLM, and its output is usually good but not perfect by any means. So far, my experience is that because you're the one typing and actually engaged, you catch the weird stuff (and I'm finding that pushing back on it is its own kind of learning). And yes, it's vibecoded, because it's low scope, low risk, and scratching a personal itch. I run it on Claude Code + macOS personally, other setups should work but I haven't been able to verify them yet.
If you can find resources to learn something that was written by a human, read that first. But Lathe is here to fill in the gaps when that isn't the case, and I hope it serves as an example where LLMs can help us think better, rather than less.
Repo: https://github.com/devenjarvis/lathe
Would love your feedback if you decide to check it out!

value: Show HN: Lathe – Use LLMs to learn a new domain, not skip past it

author: devenjarvis


value:
Strataris is a first-person colony-defence shoot-'em-up for macOS — Defender by way of Rescue on Fractalus. But the reason I'm posting it here is the build constraint: there are no asset files at all. No textures, no audio files, no 3-D models, no fonts.
Everything is generated in code:
- Terrain is fractal-noise (fbm) heightmaps rendered as a GPU triangle mesh, height-banded and slope-shaded, that composites with a hand-built 2-D HUD and gets blit-upscaled nearest-neighbour for the pixelated look.
- Ships & buildings are flat-shaded low-poly hulls, a handful of triangles each.
- Music & SFX come from a from-scratch synth (square/saw/triangle/noise/rumble voices plus a Karplus-Strong plucked string, with envelopes, overdrive and a limiter). The title theme is an original generative build.
- Radio comms are speech rendered offline and band-pass-filtered into a crackly cockpit-radio timbre, with squelch and roger bleeps.
- Fonts are a 5×7 bitmap for the HUD plus a Core Text rasteriser.
The result is ~0.85 MB per architecture — smaller than the asset payload of many single web pages, and it fits on a 1.44 MB floppy with room to spare. Native Swift + Metal, no engine.
It's open source (the renderer is the interesting part) and free. Builds as a universal binary via a gmake pipeline. Would love feedback from anyone who's done procedural/demoscene-style work.
Source + downloads: https://github.com/PerpetualBeta/Strataris
Product page: https://jorviksoftware.cc/games/strataris

value: Show HN: A macOS game with zero asset files – terrain, sound, art all generated


value: colmanhumphrey

value:
Hey HN,
I love Schelling point questions, where you have to guess what other people will answer, with them trying to do the same. So I built a little daily game with them, but also the opposite: try to avoid what everyone else picks (while they're avoiding too).
There are four scored questions each day, generally two converge questions (match the crowd, classic Schelling point questions), and two diverge (avoid the crowd). There's also one "seed" question for a future day mixed in.
You get scored against everyone who answered before you, so your score doesn't change if loads of people change the distributions after you.
Initial distributions might be a bit thin today, but hopefully it's still fun.
Cheers! And let me know if you have any fun suggestions for future questions.
Colman

value: Show HN: Mind the Hive – a daily Schelling-point game (match or dodge the crowd)

author: colmanhumphrey


value: katzito

value: Show HN: PWNC – A dependency-free web platform I've been building for 25 years

author: katzito


value: Git/GitHub did not evolve for agentic era, so we are building

value: Show HN: Version Control for AI Agents

title: Show HN: Version Control for AI Agents


value: ABSALOMMAXY

value:
We kept seeing the same problem: creators make great content but the moment they dub it into another language, everything falls apart. Robotic voice. Music gone. Meaning lost. Lips not matching.
So we built Vaani. Whatever language you create in, wherever you are in the world, your content can reach a global audience. We clone your voice, match your gestures, preserve your music, and optionally sync your lips to the new language. 10+ Indian languages, 20+ global languages, all in minutes.
We built it for 2 reasons:
So creators never have to sound like a robot in another language again
So the same video you already made can reach a global audience without filming twice
Would love your feedback.
app.vaani.media

value: Show HN: We built a tool to dub any video in the original voice in 40 languages

author: ABSALOMMAXY


value: Show HN: Every Claw Deserves a Face

title: Show HN: Every Claw Deserves a Face


value: Show HN: TeamOlimpo: Handoffs and mandatory SOPs for multi-agent coordination


value: Show HN: pypoLCA – Latent Class Analysis and Regression in Python


value: hunterx

value: Show HN: Create and Maintain Filesystem Structures for LLMs [v1.0.11 Out]

author: hunterx


value: toyoshi

value: Show HN: Inbox-beam – notifications in your inbox without sending email

author: toyoshi


value: seokjume

value: Show HN: A virtual thermal printer for testing ESC/POS receipts

author: seokjume


value: giammiferr

value: Hi everyone I just created Deja, a tool that instead of only surfacing commands that start with what you've typed, suggest what you actually want to run. I built it because I was using zsh autosuggestions but got tired of typing the same commands again and again. So Deja predicts your next command from your history.<p>Let me know what you think

value: Show HN: I made a better zsh autosuggestion tool that predicts your next command

author: giammiferr


value: wavever

value: Show HN: LimitPing – Keep Claude Code and Codex rate-limit windows continuous

author: wavever


value: dsemianovich

value: Show HN: keep it simple. – a free focus timer for iPhone & iPad

author: dsemianovich


value: Show HN: WibeOS, an OS where every app is hallucinated by an LLM


value: Show HN: Converted my Gmail into an agent to work for itself


value: reybahl

value: Show HN: Vithos – typesafe full-stack template for Cloudflare Workers

author: reybahl


value: yusufnb

value:
Hey HN,
I pivoted few months back from a B2B idea to B2C after talking to lots of developers and agencies. Looking for feedback, thoughts on this updated product launch.
Why another vibe coding platform?
First, this is not a vibe coding platform. It is a complete cloud website development platform with a vibe-coding interface. Underneath is a headless CMS, a static site builder, entire infrastructure and plumbing. This allows you to build one page landing site to a large multi-site corporate websites, all in one place.
It comes with a built in AI agent but also a unique Bring Your Own Agent approach that allows you to use expensive models via your subscriptions that you can run for hours on your local machine, that can give you amazing outputs. Think generating a large quality 100+ page corporate website with accurate data in a matter of couple of hours. Totally doable.
And to top that, there are no git repos, servers, databases or hosting providers to deal with.
Its a one man show so far, so please bear with any glitches/inconsistent docs.
Please give it a try. Feel free to reach me directly at yusuf at sleekcms for any questions, comments, partnerships, integrations.
Thanks.

value: Show HN: SleekCMS – Lovable for Websites

author: yusufnb


value: Show HN: YouTube Roulette – one button, a random video


value: qainsights

value: Show HN: Achu.app – turns raw captures into polished visual, with AI Issue Agent

author: qainsights


value: roadbar

value: Show HN: Roadbar – Gantt-style Jira deadline tracker

author: roadbar


value: Rochus

value: Show HN: A parser for the ISO 10303 EXPRESS language for its 40th anniversary

author: Rochus


value:
Hello HN,
I've been working on a simple OS for tinkering and running bare metal apps on vintage PCs.
Since I couldn't quite decide whether to target pure 16-bit, or slightly more capable 32-bit machines, I ended up with two separate versions:
- GentleOS/32 (https://github.com/luke8086/gentleos32) works on i386+, requires 4MB of RAM and VGA display supporting 640x480x16 mode or any 256-color VESA mode.
- GentleOS/16 (https://github.com/luke8086/gentleos) works on 80186+, requires less than 192KB of RAM and a CGA display supporting 320x200x4 mode.
You can find more details in the repos.

value: Show HN: GentleOS – A pair of hobby OSes for vintage 32-bit and 16-bit PCs


value: ataturkle

value: Honestly I just like the Drudge layout and wanted more relevant articles

value: Show HN: Sudo Report – Drudge clone for tech / AI / product

author: ataturkle


value:
SourceLibrary.org is currently the world’s largest online library of translated ancient sources. It contains over 15,000 books translated from dozens of languages (Latin, Greek, Chinese, Sanskrit, Arabic, Hebrew, Egyptian, etc)—from sacred texts to early science. Our vision is to make ancient wisdom accessible to both people and AI.
Did you know that less than 3% of the Latin Renaissance has ever been translated into English?
This is ironic, because translations of ancient Greek wisdom texts are historically credited with helping to ignite the Renaissance. Yet, the Renaissance itself was mostly written in NeoLatin and it is currently 97% untranslated.
For scale, the word count of SourceLibrary.org just exceeded English Wikipedia. In addition to the texts, there are hundreds of thousands of searchable images.
SourceLibrary is free and open-source (AGPL3). Scans are mostly public domain and translated texts are Creative Commons share-alike.  All is accessible via MCP or API. Point Claude Code or Codex at sourcelibrary and see what it is like when it can search and quote source texts. E.g., ask Claude Code to compare alchemical practices in Latin, Chinese, Sanskrit etc — and ask for images.
SourceLibrary.org is an open source initiative of the Embassy of the Free Mind (https://www.EmbassyoftheFreeMind.com), a Dutch nonprofit with 501c3 status and home to the Biblioteca Philosophica Hermetica, a UNESCO recognized “Memory of the World” rare book library. SourceLibrary is entirely supported by tax-deductable donations. Corporate sponsorships and partnerships are also welcome: https://sourcelibrary.org/support
We invite you to participate in this historical effort to translate the Renaissance and beyond. In addition to the digital impact, we hope to manifest long-term institutional support for the (global) human stewardship of these materials.
HN, please sign up for free and leave feedback (found at the bottom of every page). If something is annoying or improper or hard to use — please share. I read feedback almost every day. Maybe test out the librarian https://sourcelibrary.org/librarian — it’s a research agent that can retrieve quotes and images in chat.
If this project resonates with you, please let me know what you find!
Derek
Acknowledgments: Thank you to my friends at playpowerlabs.com, getsmartpaper.com and Wisdom-Frontier.org for concept and development support and to https://www.frond.studio/ for design support

value: Show HN: Help SourceLibrary.org Translate the Renaissance


value: leomos

value:
Hello HN,
I built this tool to compare multiple solar panels for my rooftop and get a monthly energy production report based on input location.
Some notes:
- calculations are done using PVGIS
- the only supported rooftop shape is rectangular (for now)
- it's possible to upload a solar panel PDF datasheet or parse a URL containing the details but in this demo instance I only allow the access to a static catalog of ~10k solar panels (LLM inference costs :D)
Feedbacks are more than welcome,
Thanks!

value: Show HN: Solectio – design, compare and share rooftop solar configurations

author: leomos


value: Show HN: macOS motion design app built for demos and promos


value: ahshucks

value: Show HN: Free job postings API with 1.8M+ US jobs, 60k companies

author: ahshucks


value: mksglu

value: Show HN: Context Mode Insight – observability layer for AI coding agents

author: mksglu


value: mcintyem

value: Show HN: OpenPayphone – open-source guts for a 1996 coin payphone (Pi and SIP)

author: mcintyem


value: sastra

value:
Conventional logos are perfectly consistent everywhere: the same proportions, spacing, colors, every time.
I wanted to try something that goes against this corporate uniformity and come up with a logo system that can be individualized but is still recognizable as the company’s logo.
The final implementation is heavily inspired by IDEO, where internal teams could choose slightly different versions of the logo by rearranging the letters within a grid. I also wondered about allowing logos to be put in bold so I added that functionality.
The last motivation was practical. I get asked for different file formats and background-compatible versions of the logo. So I made this configurator tool that lets you customize your own version of the Monomer Bio logo, select file format, specify color configuration to match your background, and put it in bold for emphasis if you want.

value: Show HN: An app to configure my company's logo

author: sastra


value: shashanoid

value: Show HN: Find conversations happening for your product or business

author: shashanoid


value: Show HN: AgentCrew – a Markdown-first operating system for AI coding agents


value: farcaster

value: Show HN: A 178K Neural Net that beats Pokémon Roguelike

author: farcaster


value: mertefesensoy

value:
SPD is the small EEPROM on a memory module that stores its timings, geometry, and the XMP/EXPO overclock profiles. The JEDEC standard that defines the DDR5 layout, JESD400-5, is paywalled, so there isn't a clean open reference for what each byte means.
I wrote spdr partly to have one. Every field decoder is written out explicitly and each byte offset is pinned to an open source I could cross-check against, so the code reads as a reference for the format about as much as it works as a tool. On top of the decoder there's a linter that flags values that are internally inconsistent even when the CRC passes, like a tRC that doesn't equal tRAS + tRP, or a CAS latency the module doesn't list as supported.
The core is a no_std, allocation-free, #![forbid(unsafe_code)] Rust library; the CLI is separate. Malformed input returns a typed error rather than panicking, which is property-tested over arbitrary and mutated bytes.
It's read-only (it never writes SPD), and the scope is deliberately narrow: unbuffered DDR5 UDIMMs are fully decoded, server/registered modules aren't yet, and it's only validated against one real module so far.
https://github.com/The-Open-Memory-Initiative-OMI/spdr

value: Show HN: Spdr, an open DDR5 SPD decoder and linter (JESD400-5 is paywalled)

author: mertefesensoy


value:
Vibe-coded a baseball version of the viral 82-0 basketball game. Codex essentially one-shotted this which was impressive to say the least. Of course the small nuance and polish was still to be done, but the prompt below did 95% of the work within 30 minutes.
I'd like to build a web app that is a sports stats/simulation combination game.
The basis of the game is you get to pick one player at each position - LF, CF, RF, 3B, SS, 2B, 1B, C, SP, RP so 10 players total.
The way you choose a player is by pressing a "SPIN" button that randomly picks an MLB team and year from anytime in the last 50 years.
You are then presented with the players and their statistics on that team and that year as options to fill one of the empty slots you have not filled in your lineup. There will be 10 spins to fill each of the 10 spots. You can fill the spots in any order you wish, but only 1 player for each spot. So, if you pick a starting pitcher from the 1985 Cardinals for your first pick, you can no longer pick a starting pitcher on the next turn.
After all roster spots have been filled, we will run a simulation to evaluate/predict what the record would be for the team based purely on the statistics of those players from only the year/version of that player.
Things we need for this:
1) We need to build a database of players and years and statistics from each year. It would be like:
For hitters:
Player, Team, Year, Batting Avg, Runs, HR, RBI, SB
For pitchers:
Player, Team, Year, Wins, Losses, Saves, ERA, WHIP, SO
So if we do not have those statistics we cannot build this. That is the first question I need answered. If yes, we should proceed.

value: Show HN: Baseball version of the popular 82-0 game


value: Show HN: GitMo – Google Drive-like auto sync for GitHub


value: poppypetalmask

value: Show HN: Convert a lunar birthday into 60 years of calendar reminders

author: poppypetalmask


value: kzahiri

value: Show HN I scraped 743 large employers' careers pages to find their ATS

author: kzahiri


value: axiomaxllc

value: Show HN: Axiomax – Cryptographic proof of AI inference carbon footprint

author: axiomaxllc