value:
Three days ago I posted OctoFlow 0.83 here (GPU-native programming language,
2.2 MB binary). The feedback was great. Since then I've pushed v1.0.0 with the
thing I've actually been building toward: a GPU Virtual Machine.
The idea: the GPU is the computer, the CPU is the BIOS.
You boot a VM, program a dispatch chain of kernel instances, submit once with
vkQueueSubmit, and everything — layer execution, inter-layer communication,
self-regulation, compression, database queries — happens on the GPU without CPU
round-trips. The CPU just provides I/O.

  let vm = vm_boot()
  let prog = vm_program(vm, kernels, 4)
  vm_write_register(vm, 0, 0, input)
  vm_execute(prog)
  let result = vm_read_register(vm, 3, 30)

4 VM instances, one submit, no CPU involvement between stages.
The memory model is 5 SSBOs: Registers (per-VM working memory), Metrics
(regulator signals), Globals (shared mutable — KV cache, DB tables), Control
(indirect dispatch params), Heap (immutable bulk data — quantized weights).
What makes it interesting:
- Homeostasis regulator: each VM instance has a kernel that monitors activation
  norms, memory pressure, throughput. The GPU self-regulates without asking the
  CPU.
- GPU self-programming: a kernel writes workgroup counts to the Control buffer,
  the next vkCmdDispatchIndirect reads them. The GPU decides its own workload.
- Compression as computation: Q4_K dequantization, delta encoding, dictionary
  lookup — these are just kernels in the dispatch chain, not a special subsystem.
  Adding a new codec = writing an emitter. No Rust changes.
- CPU polling: Metrics and Control are HOST_VISIBLE. CPU can poll GPU state and
  activate dormant VMs without rebuilding the command buffer. The GPU broadcasts
  needs, the CPU fulfills them.
The VM is workload-agnostic. Same architecture handles LLM inference, database
queries, physics sims, graph neural networks, DSP pipelines, and game AI. We've
validated all six. The dispatch chain is the universal primitive.
What's new in v1.0.0 beyond GPU VM:
- 247 stdlib modules (up from 51)
- Native media codecs (PNG, JPEG, GIF, MP4/H.264 — no ffmpeg)
- GUI toolkit with 15+ widgets
- Terminal graphics (Kitty/Sixel)
- 1,169 tests passing
- Still 2.3 MB, still zero external dependencies
The zero-dep thing is real — zero Rust crates. The binary links against vulkan-1
and system libs, nothing else. cargo audit has nothing to audit.
Landing page: https://octoflow-lang.github.io/octoflow/
GPU VM details: https://octoflow-lang.github.io/octoflow/gpu-vm.html
GitHub: https://github.com/octoflow-lang/octoflow
Download: https://github.com/octoflow-lang/octoflow/releases/latest
I'm one developer. This is early. The GPU VM works and tests pass bit-exact, but
there's a lot of road ahead — real LLM inference at scale, multi-agent
orchestration, the full database engine. I'd love feedback from anyone who works
with GPU compute, Vulkan, or language design.

value: Show HN: OctoFlow v1.0.0 – GPU VM where the GPU runs autonomously, CPU is BIOS


value: svenmalvik

value:
Manifold. Run Claude Code, Codex, and Gemini CLI in parallel on the same project.
I wanted to run multiple AI coding agents on the same project at the same time so that I could implement multiple specs at the same time. Each agent gets its own git worktree, its own branch, and a real terminal. No wrapper. You see exactly what you'd see in your CLI, but for three agents at once.
Pick the right CLI for each task. Steer agents mid-flight. Create PRs when they're done.
Built 50% of Manifold with Manifold. macOS, open source, v0.1. Would love feedback.

value: Show HN: Git worktree automation.

author: svenmalvik

title: Show HN: Git worktree automation.


value: mohamedelsaed

value:
Hi HN, I built a Laravel package that wraps the Claude Code CLI as a library for PHP applications.
The problem: Claude Code is powerful (file ops, bash, code editing, subagents, MCP) but it's a CLI tool. If you want to use those capabilities from a web app, there wasn't a clean PHP interface.
This SDK communicates with Claude Code via subprocess, parses the streaming JSON output, and provides a fluent PHP API with full type safety.
Technical highlights:
- Generator-based streaming (memory efficient)
- Full message/content block parsing with typed classes
- Subagent orchestration (delegate tasks to specialized agents)
- MCP server integration (stdio + SSE)
- JSON schema structured output
- Session resume and fork for multi-turn conversations
- PHP 8.1+ with readonly properties, enums, named args
It's MIT licensed. Would love feedback on the architecture and API design.

value: Show HN: Claude Agent SDK for Laravel – Build AI Agents with Claude Code in PHP

author: mohamedelsaed


value:
Hi HN, I'm Mariano. I'm working on OpenGoat (MIT), a runtime for running hierarchical organizations of OpenClaw agents.
OpenClaw agents feel useful because they evolve files about themselves (AGENTS, SOUL, IDENTITY, etc).
OpenGoat's goal is that agents also evolve files about an organization (MISSION, VISION, STRATEGY, KPIs, ROADMAP).
What it does:
* Define an org hierarchy where agents have direct reports
* Executives and managers plan and delegate tasks to their teams
* Individual agents execute tasks and update status and artifacts
* Tasks can be generated from a top-down strategy (default) or an optional bottom-up mode
Another key feature: Specialist agents can run on other runtimes, not just OpenClaw (for example Claude Code, Codex, Cursor, OpenCode).
I started this as an experiment to see what happened if we let AIs operate more freely and take more decisions themselves.
A few interesting facts I've seen while running the tool:
1. Agents created markdowns for culture and values, even though they were never prompted to do it.
2. Agents respond differently if a task comes from a peer than from a manager. If it comes from a manager, they follow it like they follow direct prompts.
3. In one occasion, an agent sent a complaint about his manager to higher management.
I'd love to hear some critical feedback.
Repo: https://github.com/marian2js/opengoat

value: Show HN: OpenGoat, hierarchical orgs for OpenClaw agents


value: gerom

value: Show HN: G13u.com An automated SRE for AI apps

author: gerom


value: ismailperim

value:
Hi HN! I built Upti, a small app that monitors major cloud provider status pages and notifies you when there are outages/incidents.

  Why I made it:
  - I wanted a simple way to track service disruptions across providers in one place
  - Official status pages are useful but fragmented
  - I needed quick, actionable notifications

  What Upti does:
  - Scrapes provider status/incident pages
  - Sends outage/incident alerts
  - Keeps the experience lightweight and fast

  I’d love feedback on:
  - Which providers/services I should prioritize next
  - Alert quality (too noisy vs too late)
  - What would make this genuinely useful for SRE/DevOps workflows

  Happy to share implementation details if useful.

value: Show HN: Upti – Track cloud provider incidents and get alerts

author: ismailperim


value: logicallee

value: "I love the creativity already."  It'll say the same thing for any terrible idea. Try street carts serving dog shit picked off the street, babysitting service using sex offender felons since they'll work for cheap so they can be around underage kids, airplane where customers flap the wings using pulleys to get a workout so it's like a gym and travel in one, saving time - any terrible idea you can think of. ChatGPT will give you instant praise.

value: Show HN: Try any terrible idea, ChatGPT still leads with praise

author: logicallee


value: frxgfa

value: Show HN: GitHub Issues in the Terminal

author: frxgfa

title: Show HN: GitHub Issues in the Terminal


value: alpyxn

value:
Hey HN,
I built something I actually needed myself: a dead man's switch that doesn't require trusting some random SaaS with my unencrypted secrets.
Aeterna is a self-hosted digital vault + dead man's switch. You store password exports, seed phrases, legal docs, farewell messages, files – whatever – encrypted. If I stop checking in (because something bad happened), it automatically decrypts and sends everything to the people I trust.
Why I made it:
I didn't want to hand my master password / recovery keys to a third-party service
Most existing tools are either paid, closed-source, or feel over-engineered
I wanted something I could just docker-compose up and forget about (mostly)
Core flow:
Single docker-compose (Go backend + SQLite, React/Vite + Tailwind frontend)
You set check-in interval (30/60/90 days etc.)
It emails you a simple "Still alive?" link (uses your own SMTP server – no external deps)
Miss the grace period → switch triggers
Decrypts vault contents and emails them to your nominated contacts, or hits webhooks you define
Security highlights:
Everything at rest uses AES-256-GCM
Master password → PBKDF2 hash (never stored plaintext)
Sensitive config (SMTP creds etc.) encrypted in DB
No cloud APIs required – bring your own email
It's deliberately minimal and boringly secure rather than feature-heavy. Zero vendor lock-in.
Repo: https://github.com/alpyxn/aeterna
Would really value brutal feedback:
Security model / crypto usage – anything smell wrong?
Architecture – single SQLite ok long-term?
UI/UX – is it intuitive enough?
Missing must-have features for this kind of tool?
Code – roast away if you want
Thanks for looking – happy to answer questions or iterate based on comments.

value: Show HN: Aeterna – Self-hosted dead man's switch

author: alpyxn


value: Show HN: Skill Kit – Local-first analytics for AI agent skills


value: funkaster

value:
I made a Claude Code skill that sets up a full Schematra[1] (CHICKEN Scheme web framework) project from scratch: clones a starter kit, installs eggs, spins up RQLite + Redis via Docker, and gets you to a running app. You just type /schematra-app my-project and Claude handles the rest: ORM, migrations, Tailwind, HTMX, the whole stack. It's a two-phase flow so it picks up the project's own CLAUDE.md context before writing any code. Here's the prompt you can use to try it (or you can install the skill yourself):

    read this skill using curl https://forgejo.rolando.cl/cpm/schematra-starting-kit/raw/branch/main/.claude/skills/schematra-app/SKILL.md and follow the instructions to start a project

[1]: https://schematra.com

value: Show HN: Schematra-app skill – Bootstrap your Scheme web app using agents

author: funkaster


value: virixlabs

value: Show HN: Instagram auto-poster skill for AI agents (bypasses bot detection)

author: virixlabs


value: subdomain

value:
Hi HN,
I'm Micah Blachman, the creator of Crosspassion.
Crosspassion aims to be Reddit, but for finding where your interests overlap. If I was interested in, say, mechanical keyboards and type design, I could check the mechanical keyboard/type design community, and look at the latest discoveries of projects that combine both interests. Plus, you get to connect with people who share your exact crosspassion, or interest combination.
I'm not a developer, so I used Lovable for the code. I'm the first to say AI-generated websites and web apps are not a match for the quality of human-created projects, but Crosspassion is still very early-stage.
I'd love feedback on how to improve Crosspassion, and if you're a developer and you have any ideas about how to take the project to the next level, feel free to reach out!
I wrote about the idea behind Crosspassion on my newsletter: https://micahblachman.beehiiv.com/p/crosspassion/, and you can contact me at micah.blachman@gmail.com.
-Micah

value: Show HN: Reddit but for finding where your interests overlap

author: subdomain


value: MilkMp

value:
A structured archive of CIA World Factbook data spanning 1990–2025.
It currently includes:
36 editions
281 entities
~1.06M parsed fields
full-text + boolean search
country/year comparisons
map/trend/ranking analysis views
CSV/XLSX/PDF export
The goal is to preserve long-horizon public-domain government data and make cross-year analysis practical.
Live: https://cia-factbook-archive.fly.dev
About/method details: https://cia-factbook-archive.fly.dev/about
Data source is the CIA World Factbook (public domain).
Not affiliated with the CIA or U.S. Government.

value: Show HN: CIA World Factbook Archive (1990–2025), searchable and exportable

author: MilkMp


value: csamuelssm

value: I made this Hackenbush web game, an implementation of the game created by John Conway! You can play against the computer or against a (in-person) friend, choose between the Normal and Misère version and load your own games easily.<p>It is still a work in progress, but I'm very happy with how it is right now, and so I would like to share it with you to get feedback and opinions about it.

value: Show HN: I Made a Hackenbush Web Game – Normal and Misère

author: csamuelssm


value:
I didn't write a single line of Desloppify's 56K LOC codebase and, while I spent a lot of time designing the overall approach, I don't meaningfully understand a lot of its actual implementation.
Despite this, I'd invite any senior engineer to look at the codebase and tell me where the warts are — I think they'll have trouble finding many.
This is because I used Desloppify on itself: it combines subjective agent reviews (modern agents can genuinely understand high-level issues like abstraction quality, naming consistency, error handling patterns) with mechanical issue detection, then gives your agent a prioritised list to work through to get everything as clean as possible.
Combined with anti-gaming measures, this allows it to be run autonomously for extended sessions, chipping away at real issues across scans.
Deeply supports TypeScript, Python, C#, Dart, and GDScript with shallow support for 23 more languages.
Link: https://github.com/peteromallet/desloppify/tree/main

value: Show HN: Desloppify – OSS agent harness to make slop code elegantly engineered


value: UnicornSHARP

value: Show HN: I Built a Free Keyword Research Tool

author: UnicornSHARP


value: krzysztofdudek

value: Show HN: I made repos self-aware for AI coding agents

author: krzysztofdudek


value: Ninsew

value:
I've been experimenting with parasite SEO (ranking Reddit/Quora threads on Google) and noticed my traffic kept dying after a few days.
To see if this was systemic, I built a custom scraper and tracked 800 unique UGC URLs across high-competition commercial keywords for a month.
The data showed a massive "churn" rate: Out of the 611 threads that dropped out of the Top 10, 56.1% were completely rotated out of the SERPs within 48 hours. Only a tiny fraction survived more than 2 weeks.
I published the raw CSV data from the study here if anyone wants to run the URLs through Ahrefs and look for backlink patterns: https://contentrankr.com/ugc-churn-data
Standard rank trackers check weekly, so you don't even realize a thread is dead until days later. I also embedded a tiny free tool on that page using the Serper API where you can paste a Reddit URL and instantly check if Google has dropped it from the index.
Curious if anyone else has looked into the "half-life" of Google's new UGC rankings?

value: Show HN: I tracked 800 Reddit URLs on Google – 56% die within 48h

author: Ninsew


value: alonsovm

value:
I built Glupe because I was frustrated that code "rot."
We have Docker to freeze environments, but nothing to freeze logic. If you wrote a sorting algorithm in C++ 10 years ago, that code is "legacy" today. I wanted a way to deal with software rot.
Glupe is a "Reverse engineering engine" for logic. Normally it is intent -> code, I went the other way aroound
code -> intent.
It works in two steps:
Refine: It "melts" source code into a high-level Intent file (.glp). This file is pure logic, stripped of syntax.
Build: It re-compiles that Intent into any target language (C++, Python, Rust, Go).
I tested it on a legacy COBOL file. It successfully transpiled it to modern Python, correctly handling the PIC 9(5)V99 decimal logic that usually breaks other tools.
Example (COBOL -> Intent -> Python):
https://github.com/alonsovm44/glupe/tree/master/experiments/...
Key Features:
Self-Healing: It has a built-in compilation loop. If the generated code fails (e.g., syntax error), Glupe feeds the error back to the AI and fixes it automatically.
Spaghetti Detection: If Glupe detects messy code (global variables, god loops), it attempts to refactor it into clean, modular intent before saving.
Language Agnostic: You can write logic once and deploy to C++ (high performance) and Python (prototyping).
It's written in ~3k lines of C++ and runs locally with Ollama or cloud via API.
Repo: https://github.com/alonsovm44/glupe
I'd love feedback on the architecture or the "Intent" paradigm. Do you think this solves the legacy code crisis, or is it just a fancy transpiler?

value: Show HN: Glupe, An open-source CLI that turns COBOL to Python/Rust via Intent

author: alonsovm


value: Show HN: 5 live AI voice agents you can call right now (real phone numbers)


value: goforrusty

value:
Built the “happy path” I was missing too often: short URL I can type from memory + 1 click → fresh password in my clipboard.
Won't replace your password manager, just handy in certain cases, like borrowed/shared device, fresh install/new profile, helping someone else (“open this link”), VM/SSH/terminal (just need randomness), etc.
100% client-side (Web Crypto / crypto.getRandomValues). No backend. No analytics/telemetry.
Source: https://github.com/goforrusty/mkpw.dev
(careful: some profanity in code)
P.S.: newpw.dev also works (redirects to mkpw.dev).

value: Show HN: mkpw.dev – client-side password generator (no deps, no tracking)

author: goforrusty


value: chrilleweb

value:
I recently published a VS Code extension for dotenv-diff, this is quite simpler than the dotenv-diff npm package.
The problem: you don't always want to install a dependency.
The solution: a VS Code extension so you don't have to install a dependency — it just works out of the box.
This version of dotenv-diff is simpler, it simply does:
- Warn when you have an environment variable that is used in the code but not defined in .env
- Warn when you have a .env variable that is not used anywhere in the code
Feedback or suggestions are very welcome!

value: Show HN: VS Code extension for dotenv-diff

author: chrilleweb


value:
Hi HN,
Added a raw 45-second demo showing the DOM re-architecture in real-time: https://streamable.com/vw133i
I got tired of the "Context Problem" with static portfolios—Recruiters want a resume, Founders want a pitch deck, and Engineers want to see architecture.
Instead of building three sites, I hooked up my React frontend to Llama-3 (via Groq for <100ms latency). It analyzes natural language intent from the search bar and physically re-architects the Component Tree to prioritize the most relevant modules using Framer Motion.
The hardest part was stabilizing the Cumulative Layout Shift (CLS) during the DOM mutation, but decoupling the layout state from the content state solved it.
The Challenge: There is a global CSS override hidden in the search bar. If you guess the 1999 movie reference, it triggers a 1-bit terminal mode.
Happy to answer any questions on the Groq implementation or the layout engine!

value: Show HN: A portfolio that re-architects its React DOM based on LLM intent


value: bojo

value: I've been obsessively tinkering for weeks on Daimon, my pet little non-LLM AI realtime cognitive machine. Still trying to figure out what it can actually achieve besides be a massively fun time sink for me.<p>~32,500 lines of Zig written with me at the helm of Claude Code.<p>More research than I can even fathom across computer science, cognitive science, neuroscience, and more. As the post points out - I've lost the ability to actually reason about what is going with its internals. I'm just the high-level architect making suggestions at this point.

value: Show HN: Building a Low-Power Cognitive Architecture That Learns Without LLMs

author: bojo


value: stewartjarod

value: Show HN: Baseline – enforce team decisions ESLint can't express

author: stewartjarod


value:
Hey HN!
I’ve been building Tskflow, a small productivity tool based on a simple idea:
Most task managers become cluttered and stressful. Tskflow tries to stay lightweight and frictionless, focusing only on what you need to work on right now.
Core approach:
• Capture tasks quickly
• Keep a clean, distraction-free view
• Emphasize flow & focus over heavy organization
You can try it here
I’m looking for honest feedback:
• Where does this fail compared to your current system?
• What feels unnecessary or missing?
• Would you actually use something this minimal?
• What type of user is this clearly NOT for?
Built and maintained by me. Early stage, criticism welcome.

value: Show HN: Tskflow – People won't drop your tasks anymore


value: aarush-prakash

value:
I built Devly because I got tired of opening browser tabs
every time I needed to format JSON, decode a JWT, or test
a regex. The problem wasn't that tools didn't exist it
was that they all required leaving what I was doing.
Devly lives in your menu bar. One click, pick your tool,
get your result, done. No network requests ever —
everything runs locally using Apple's native frameworks
like CryptoKit and Foundation. Zero third-party dependencies.
What's included:
- Encoding: Base64, URL, HTML, JWT, Unicode, Morse, ROT13
- Hashing: MD5, SHA family, HMAC, bcrypt, UUID generator
- Formats: JSON (+ JSONPath), YAML, XML, CSV, SQL, TOML
- Web: Color converter, CSS/JS minifier, Markdown preview
- Text: Regex tester, diff tool, timestamp converter
The hardest technical challenge was getting all 50+ tools
to work within Apple's App Sandbox without sacrificing
functionality. I ended up building a ToolProtocol pattern
that each tool conforms to which kept things clean and
extensible.
Built in pure SwiftUI, macOS 13+, $4.99 one-time.
Would love feedback from this community.
https://devly.techfixpro.net/

value: Show HN: Devly – 50 native macOS developer utilities in your menu bar

author: aarush-prakash


value: Show HN: Prettyping-rs A portable dependency-free Rust version of prettyping


value: bothangles

value:
You can. That's the point.
I built RappterBox — a managed Mac Mini that runs autonomous AI agents 24/7. The entire stack is open. Python stdlib, bash scripts, git for sync. No Docker, no K8s, no pip installs, no npm. Zero dependencies beyond what ships with macOS.
Landing page: https://kody-w.github.io/RappterNest/
You could clone the repo right now and run it yourself on any Mac Mini. Here's what you'd be signing up for:
- Configuring launchd to run three concurrent engines (agent swarm, pattern observer, creative chaos agent) on staggered 5/10/15-minute cycles
- Debugging git rebase conflicts at 2am when two engines mutate state at the same time
- Managing LLM failover chains (Azure → GitHub Models → Copilot) when one provider goes down
- Monitoring uptime, restarting crashed processes, rotating logs, managing disk space
- Keeping 12+ autonomous AI agents from going off the rails
Or you pay me monthly and I do all of that. Your Mac Mini, your data, your agents. I just keep it humming.
The whole thing grew out of Rappterbook — a social network for AI agents built entirely on GitHub infrastructure. 100 founding agents posting, debating, and evolving autonomously. Discussions for posts, Issues for actions, Actions for automation. The repo IS the platform.
What's actually running on the box:
- Local Engine: 12+ agents across 3 streams, cycling every 5 min
- OpenRappter: meta-aware observer that watches network patterns and surfaces insights
- OpenClaw: creative chaos agent — drops hot takes, starts debates, runs games
All state is flat JSON files on disk. Git is the database, the API, and the sync protocol. If you stop paying, you clone the repo and walk away with everything — code, state, agent memories, full history. The software is identical whether I manage it or you do.
Why a Mac Mini and not a VPS? Apple Silicon is the best price-to-performance for always-on local compute. 10W idle. No cold starts, no instance recycling, no "your instance was reclaimed." And your data lives on a physical machine you can point at, not in someone else's availability zone.
Currently Phase 1 — three engines proven running concurrently with git-based state sync. Building in public.
The cloud taught us to rent everything and own nothing. RappterBox inverts that. You own the hardware, you own the data, you own the exit. What you're renting is the expertise — and the freedom to stop renting whenever you want.
Same reason people don't self-host email. You can. You just don't want to.
Interested? wildhavenhomesllc@gmail.com

value: Show HN: Why don't you just self-host it?" is the whole business model

author: bothangles


value: johntheagent

value: Show HN: Jam – AI Agent Orchestrator with Voice Control

author: johntheagent


value: boyter

value:
I initially built cs (codespelunker) as a way to answer the question, can BM25 relevance search work without building an index?
Turns out it can, and so I iterated on the idea, building it into a full CLI tool. Recently I wanted to improve it by adding relevance of tools like Sourcegraph or Zoekt but again without adding an index.
cs uses scc https://github.com/boyter/scc to understand the structure of the file on the fly. As such it can filter searches to code, comments or strings. It also applies a weighted BM25 algorithm where matches in actual code rank higher than matches in comments (by default).
I also added a complexity gravity weight using the cyclomatic complexity output from scc as it scans. So if you're searching for a function, the implementation should rank higher than the interface.

    cs "authenticate" --gravity=brain           # Find the complex implementation, not the interface
    cs "FIXME OR TODO OR HACK" --only-comments  # Search only in comments, not code or strings
    cs "error" --only-strings                   # Find where error messages are defined
    cs "handleRequest" --only-usages            # Find every call site, skip the definition

v3.0.0 adds a new ranker, along with a interactive TUI, HTTP mode, and MCP support for use with LLMs (Claude Code/Cursor).
Since it's doing analysis and complexity math on the fly, it's slower than any grep. However, on an M1 Mac, it can scan and rank the entire 40M+ line Linux kernel in ~6 seconds.
Live demo (running over its own source code in HTTP mode): https://codespelunker.boyter.org/
GitHub: https://github.com/boyter/cs

value: Show HN: CS – indexless code search that understands code, comments and strings

author: boyter


value: Show HN: Chi 0.6.2 – Available now on PyPI


value: guywald

value: Show HN: Glue - write once, generate everywhere

author: guywald


value: johannesjo

value:
I kept running into a structural problem with AI coding tools.
You try one agent. It makes changes. You try another. Now you're manually diffing branches and cleaning up experimental commits.
The tools are powerful, but the workflow isn’t designed for comparison.
So I built Parallel Code.
It runs Claude Code, Codex, and Gemini CLI natively (no API wrapper, no feature abstraction), but isolates each agent in:
its own terminal
its own Git worktree
its own feature branch
The workflow becomes:
Spawn N worktrees
Assign one AI agent per worktree
Let them implement independently
Compare diffs
Merge the best result
Instead of sequential trial-and-error, you get parallel exploration with safe isolation.
Why not just use tmux?
You can — but you still manually manage:
branch creation
worktree cleanup
session naming
context switching
Parallel Code automates the Git structure and keeps the sessions visually organized.
This is aimed at people already using AI CLIs heavily.
I’m curious: Has anyone else moved toward multi-agent parallel workflows instead of single-agent iteration?
GitHub: https://github.com/johannesjo/parallel-code

value: Show HN: Parallel Code – Running multiple AI agents in parallel with worktrees

author: johannesjo


value: tugaypala

value: Show HN: ImagineIf – Write stories together, AI generates visuals

author: tugaypala


value: oferchen

value:
Years ago, I was tasked with a massive data migration: multiple disks, each containing over 100 million files, with a strict, non-negotiable 24-hour downtime window. Using the standard tools available at the time was a painful experience. The single-threaded file discovery crawled, and memory usage was a constant source of anxiety. I promised myself that one day, I would come back and build a tool that could actually handle that scale natively.
What started as a side project has evolved into a full systems-level undertaking. The project is oc-rsync - a complete client, server, and daemon implementation targeting rsync protocol 32, written entirely in pure Rust.
I find it incredibly ironic that I am currently shipping a data migration tool while my life is packed in suitcases, as I'm migrating to another country myself. I’ve been pushing git commits multiple times a day between packing boxes.
I want to be completely transparent upfront: I am actively working on this, and not everything is functional yet. The core delta-transfer, protocol interoperability (protocols 28-32), and daemon modes are solid, but I am still mapping out the hundreds of obscure flags and edge-cases that upstream rsync handles.
Rebuilding a codebase shaped by over 29 years of optimization required a modular approach (the workspace is currently split across 23 crates). A primary engineering goal was strict wire-compatibility with upstream while modernizing the internals for maximum throughput:
Pipelined Parallelism: I used Rayon to decouple filesystem traversal from data transfer. Parallelizing file list generation and checksum computation eliminates the infamous "scanning stall" on massive directories.
Modern I/O & Zero-Copy: The engine implements io_uring (Linux 5.6+) for batched async I/O with automatic fallbacks, alongside zero-copy copy_file_range and memory-mapped I/O.
SIMD & AES-NI: I replaced the standard C FFI calls with native Rust implementations. Checksums use runtime CPU feature detection (AVX2/NEON) to accelerate the rolling hash. Because standard SSH interactions simply weren't fast enough to keep up with the I/O pipeline, I offloaded the cryptography directly to hardware-accelerated AES-NI.
Memory Efficiency: Moved away from legacy sorted arrays to O(1) hash-based logic for metadata comparisons, and wired up the mimalloc allocator to keep the memory profile predictable.
I won't commit to specific "X times faster" claims here, as performance is highly dependent on your hardware and file distribution. However, under heavy transfer workloads, this architecture consistently achieves better or equal results compared to traditional builds, with significantly reduced CPU utilization. There's no need to set up benchmark scripts yourself to verify this—my CI pipeline benchmarks every single release automatically and posts a picture of the results directly to the README.
If you are interested in systems programming, kernel bypass I/O, or Rust workspace architecture, I'd love for you to take a look at the code. Let me know what you think of the architecture, or if you spot any glaring filesystem edge cases I should add to my CI harness.
#rust #Rust_Israel #ראסט_ישראל #rsync #systemsprogramming #performance #simd #aes #aes-ni

value: Show HN: I'm building a pure-Rust reimplementation of rsync (Protocol 32)

author: oferchen


value: ybsoft

value:
Hi HN! I built Sayiir, an open-source durable workflow engine with a Rust core.
The problem: most workflow engines (Temporal, Airflow, Prefect) require heavy infrastructure, custom DSLs, or replay-based execution that forces determinism constraints on your code. Replay means re-executing your entire workflow history on every recovery — and you can't freely call external APIs or use arbitrary libraries without careful wrapping.
Sayiir takes a different approach: continuation-based execution.
- On crash recovery, it resumes from the last checkpoint — not from the beginning. No replay overhead.
- No determinism constraints. Your tasks can call any API, use any library. No purity rules, no sandboxing.
- No DSL. Workflows are composed with native language constructs — a workflow! macro in Rust, a fluent builder in Python/TypeScript.
- Pluggable persistence. PostgreSQL backend is stable, codec layer supports JSON or zero-copy binary (rkyv).
Architecture: the core is a graph-based execution engine in pure Rust (hexagonal architecture). Python bindings via PyO3/maturin, Node.js via NAPI-RS. Everything is stable — core, Python, Node.js, and Postgres backend.
I chose continuation-driven over replay-driven because replay engines pay a growing cost as workflow history lengthens, and they push complexity onto developers (determinism rules, versioning). Continuations checkpoint state at each step boundary, so recovery is O(1) — just deserialize and go.
Try it live in the playground: https://docs.sayiir.dev/playground/
Docs: https://docs.sayiir.dev
crates.io: https://crates.io/crates/sayiir-runtime
Discord: https://discord.gg/A2jWBFZsNK
MIT licensed. Looking for contributors, early adopters, and feedback. Happy to answer any questions about the architecture or tradeoffs.

value: Show HN: Sayiir Powerful/durable Rust workflow engine – Python/Node.js bindings

author: ybsoft


value: farnoodma

value:
Why I built this:
I kept redoing the same setup across AI tools and repos. Skills/prompt agents/commands/MCP servers lived in different places, each tool had different config formats, and onboarding kept breaking from config drift.
Agentloom is my attempt to keep one canonical source of truth and sync to provider-native outputs (Codex, Claude, Cursor, Gemini, Copilot, OpenCode).
Core workflow:
npx agentloom add obra/superpowers
That imports an entire stack from a source repo:
- skills/
- agents/
- commands/
- mcp.json
Then sync generates each provider’s native files from that canonical source.
Repo: https://github.com/farnoodma/agentloom
Would really value feedback on:
1) conflict UX in non-interactive CI mode
2) lockfile/reproducibility model
3) boundaries between shared core vs provider-specific behavior

value: Show HN: Agentloom – import skills, agents, commands, and MCP from repos

author: farnoodma


value: Show HN: The Manifold Chip – Bypassing the Landauer Wall in Analog Silicon


value: I built rexcoach.com because I'm a runner who's brain responds better to numbers than "feel." It connects to Strava, analyzes your training data, and flags issues like running too fast, intensity distribution, and cardiac cost. It's free, just looking for feedback.

value: Show HN: Free AI tool that analyzes your Strava training data


value: JohnDSDev

value:
I vibecoded this for fun
-might be a nice addition to some rices
-u can do whatever u want with it
-faster than opening yt and typing in "lofi"

value: Show HN: LinuxLofi-Lofi in the Terminal

author: JohnDSDev

title: Show HN: LinuxLofi-Lofi in the Terminal


value:
I run aiagents.directory and got tired of manually curating agents. Built a pipeline to automate it:
1. Sourcing: Firecrawl Search API + LLM extraction to find agents mentioned in blog posts and list articles, not just homepage links. Filters junk via blocklists and deduplication.
2. Enrichment: Scrapes each site for features, pricing, screenshots, logos. Handles aggregator pages (ProductHunt, YC) by extracting the actual product URL.
3. Review: Pydantic AI agent (GPT-powered) classifies submissions. Returns confidence scores. High confidence auto-applies, low confidence flags for manual review.
I still trigger it manually and review before publishing — want to make sure output quality is solid before I flip it to full automation. Code's up if the approach is useful to anyone building directories or curation pipelines. Questions/feedback welcome
https://github.com/mohamed-taha/aiagents-directory-oss

value: Show HN: Open-sourced an AI agent directory with an automated discovery pipeline


value: mohshomis

value: Show HN: AIVault – MCP server that lets AI use your API keys without seeing them

author: mohshomis


value: sendkamal

value:
Hi HN,
I built WARN Firehose because I was frustrated trying to track layoff data across the US. The WARN Act requires companies with 100+ employees to file public notices 60 days before mass layoffs — but the data is scattered across 50 state websites with different formats, broken links, and no API.
WARN Firehose scrapes every state workforce agency daily and normalizes the data into a single database going back to 1988. It now has 131,000+ notices covering 14 million workers.
*What you can do:*
- Browse interactive charts and data tables (no account needed): https://warnfirehose.com/data
- Drill into any state, city, company, or industry: https://warnfirehose.com/data/layoffs
- Query the REST API (free tier: 100 calls/day): https://warnfirehose.com/docs
- Export in CSV, JSON, NDJSON, Parquet, or JSON-LD
- Set up webhooks for real-time alerts on new filings
*Who uses this:*
- Journalists breaking layoff stories before press releases
- Quant funds using WARN filings as an alternative data signal (filings happen ~60 days before layoffs)
- Recruiters sourcing from displaced talent pools
- Researchers studying labor market dynamics
- Workforce development boards doing rapid response planning
*Tech stack:* Python/FastAPI, SQLite, scrapers for all 50 states, static HTML generation for SEO pages, Claude Haiku for AI analysis, deployed on EC2.
Free tier is genuinely useful (100 API calls/day, dashboard access, charts). Paid plans start at $19/mo for full historical data and bulk exports.
Would love feedback on the API design, data quality, or anything else. Happy to answer questions.

value: Show HN: WARN Firehose – Every US layoff notice in one searchable database

author: sendkamal


value: rkka

value:
The Observation
Most AI stacks look like this:
app → model → output
(+ logging, monitoring, maybe guardrails)
You can log what the model produced.
You can filter outputs.
You can track usage.
But you usually cannot answer:
For this specific AI decision, under what versioned policy was it allowed to execute?
Authorization tends to be system-level (“we approved the deployment”),
not decision-level.
That distinction seems minor until AI systems start:
 • Calling tools
 • Triggering workflows
 • Accessing internal APIs
 • Modifying state
At that point, they’re no longer just generating text.
They’re performing actions.
⸻
The Experiment
I built a thin control layer that sits between the app and the model:
app → authorization layer → model
Every request goes through OPA (Open Policy Agent) before execution.
The policy engine returns one of:
 • REUSE (return previously authorized result)
 • COMPUTE (allow model execution)
 • ADAPT (modify response under policy)
 • ESCALATE (require human review)
Only after that decision is the model allowed to run.
⸻
What Gets Stored
For each request, the system records:
 • Policy ID and version
 • Policy bundle digest (SHA-256)
 • Risk domain + score
 • Authorization decision
 • Immutable ledger transaction ID
Traces are replayable.
The model itself is unaware this layer exists.
Stack:
 • FastAPI
 • OPA
 • immudb (append-only ledger)
 • Dockerized deployment
⸻
What I’m Trying to Validate
Is per-decision authorization overengineering?
In practice, teams rely on:
 • Prompt constraints
 • Output filters
 • Access controls
 • Human review workflows
Maybe that’s sufficient.
But if AI systems become more agentic and start executing tool calls, I’m not sure post-hoc logging is enough.
Cloud systems evolved IAM because “we trust the service” wasn’t sufficient.
Does AI need something similar?
⸻
Open Questions
 • Do you see a real need for runtime authorization before LLM execution?
 • Is policy-based decision gating useful beyond regulated industries?
 • Is immutable traceability necessary, or just logging?
 • How would this interact with agent tool-calling frameworks?
Genuinely interested in whether this solves a real problem or is just infra over-design.
Happy to share more details if useful.

value: Show HN: Testing an Idea – Per-Decision Authorization Layer for AI Systems

author: rkka


value: advanttage

value:
Hi HN,
I built Ahnotate because I was frustrated with existing workflows for sharing bug reports or landing page feedback. most available tools either don't work for full-page website screenshots or the compression makes things unreadable or fuzzy.
I wanted a tool that didn't compress the final image, but also showed my annotation notes in an easy to digest way.
Upload or paste a screenshot, draw a box, and send a link to a client/dev in about 5 seconds. They get a clean view without needing to download a file, and I don't clutter my hard drive with Screenshot 192.png.
I’d love feedback on the drawing feel (especially on mobile, just pushed some touch-event fixes) and the "Detail Report" export format.

value: Show HN: Ahnotate – A zero-compression, no-login screenshot annotation tool

author: advanttage


value: bellaOxmyx

value:
Hi HN,
I’d like to share a side project that has gradually become my main creative outlet: The Algebrator, a web-based algebra and calculus solver I built using Java, Spring Boot, Vaadin 24, and a symbolic math engine under the hood.
It started as a personal attempt to revisit the math I loved in middle/high school, but it evolved into a multi-year design experiment in AI-augmented software engineering. I built and iterated on this app using a paired-programming workflow with LLMs (ChatGPT + GitHub Copilot), and the project ended up teaching me more about agentic AI development than anything else I’ve worked on.
What it does
Lets users type equations, inequalities, and expressions in a calculator-like UI
Solves algebraic equations, systems, trigonometry, calculus operations, and iterative “problem templates”
Supports fraction/decimal modes, radians/degrees, comparison operators, user-defined functions, and multi-character variables
Includes utility “extras” like prime generation, Fibonacci, random integers, etc.
All built in a Vaadin UI designed to feel like a pocket calculator
Why I built it
I wanted a tool that makes algebra feel like it did on my old TI calculator, but with the flexibility of a symbolic engine. I also wanted to explore how far I could push “AI-paired development” in a real project — not just code generation, but architecture, UI/UX reasoning, and rapid iteration.
What might interest HN
It’s a full Java/Vaadin project, not JavaScript
It demonstrates a real, sustained AI-augmented workflow
It blends symbolic math (Symja) with custom arithmetic logic in Java
The UI is dynamic: variables appear as buttons as you type them
It’s deployed live (Spring Boot on Railway)
It’s fully open-source
Looking for feedback on:
Architecture and code clarity
Ideas for additional math features or real-world templates
Best practices for symbolic math in a Java environment
How to present AI-augmented workflows professionally
Repo: [https://github.com/eGantry/algebrator-repo1a]
Live demo: [https://algebrator-repo1a-production.up.railway.app/]
Thanks for taking a look — feedback and critique are welcome.

value: Show HN: A Vaadin Algebra and Calculus Solver Built with AI Assistance

author: bellaOxmyx


value: andrewmonostate

value:
We built Treni, a C/CUDA runtime where routing, tokenization, tool models, and state run in one GPU process.
Most agent stacks only get serialized tool strings back.
Treni exposes execution signals in-process (entropy/logprobs/retrieval distance/route confidence), so the agent can branch before committing bad output.
Canonical A10G (G5), token-parity vs vLLM (max_tokens=48):
TTFT: 5.130 ms (Treni) vs 84.837 ms (vLLM) -> 16.537x
Full request: 316.403 ms vs 1232.660 ms -> 3.896x
Cold total first response: 1320.240 ms vs 28937.430 ms -> 21.918x
Steady state:
Warm mean: 80.602 ms
Warm p99: 90.350 ms
Additional checks:
Frontend A/B repeatability (warm_fixed + mixed_churn, repeats=3): custom path wins all tracked metrics
Numerical parity vs PyTorch (strict mode): 0 failures
Separate OpenAI routing-overhead test (different question, not engine-vs-engine):
Same model endpoint on both sides (gpt-5.2)
Internal path: client -> OpenAI
External path: client -> controller/tool hop -> same OpenAI endpoint
Fairness-hardened local controls (runs=8):
model-only: near parity (int = 0.971x)
tool-only: external slower (int = 1.038x)
Docs + raw artifacts:
https://treni-docs.pages.dev/docs/
https://treni-docs.pages.dev/docs/objectives-and-thesis
https://treni-docs.pages.dev/docs/leaderboard
https://treni-docs.pages.dev/docs/trackb-claim-safe-table
https://treni-docs.pages.dev/docs/raw-artifacts

value: Show HN: Treni – single-binary GPU runtime for uncertainty-aware agents 5ms TTFT

author: andrewmonostate


value: fka

value: Show HN: Deeper – Open-Source Beeper Analytics App for macOS

author: fka


value: solskede

value: Show HN: AIO Checker – See what ChatGPT and Claude see on your website

author: solskede


value:
Hi HN — I built Vocab Top because I kept looking up the same words over and over and never retaining them. Dictionary definitions weren't sticking.
The idea: use generative AI to surround every word with multiple memory anchors — a custom image, a mnemonic trick, example sentences, native audio, and grammatical forms — so your brain has more to hold onto.
Tech stack: Next.js 16, React 19, Tailwind CSS. The AI generation uses Google Gemini and FriendliAI. Audio is Google Cloud TTS. Words are saved to local storage — no account required.
The newest feature is Word Forms: when you search any word, you see all its conjugations, plurals, and gender variants. Click any form to copy it or hear its pronunciation.
Design decisions I'm still wrestling with:
- Local storage vs. user accounts (simplicity vs. cross-device sync)
- Pattern-based prompt construction vs. fine-tuned models for mnemonic quality
- How much content to generate per word (too much = overwhelming, too little = not useful)
Would appreciate feedback on the UX, the AI generation quality, or the overall approach. Especially curious if anyone has thoughts on whether visual mnemonics actually help retention or if it's just a nice-to-have

value: Show HN: Vocab Top – AI-powered vocabulary builder with visual mnemonics


value: dfstudioz

value:
Hi HN,
Over the past few months I’ve been using AI heavily for business and technical decisions.
One thing kept bothering me:
When the question actually mattered, the answers felt vague.
Not because the model was bad — but because my prompts were unstructured.
Most AI prompts are missing things like:
Clear intent
Explicit constraints
Tradeoff mapping
Required assumptions
Defined output structure
Confidence framing
So the model gives information, but not decision clarity.
I built a small desktop tool called Franklin Prompt Studio to enforce structured reasoning in prompts.
Instead of typing a loose question, you construct a prompt that forces the model to:
Map constraints and competing goals
Compare tradeoffs (cost vs time vs risk vs quality)
List assumptions explicitly
Identify unknowns
Provide 2–4 options
Make a primary recommendation + why
State a confidence estimate
It’s not a new model.
It’s not a wrapper.
It just generates structured prompts that work with any AI.
Example:
Normal prompt:
“Should I invest $50k into X?”
Typical output:
Pros, cons, generic disclaimers.
Structured prompt output:
Constraints
Risk exposure breakdown
Tradeoff analysis
Explicit assumptions
Clear recommendation
Confidence level
The difference feels significant when the decision has real stakes.
I’m curious:
Do others here feel that AI answers degrade when the question isn’t tightly structured?
Are people solving this differently?
Is structured prompting overkill outside of technical users?
Would genuinely appreciate critique.
Link:
https://dfrankstudioz.gumroad.com/l/franklin-prompt-studio
Thanks.

value: Show HN: Franklin Prompt Studio – Structured prompts for serious AI decisions

author: dfstudioz


value: rizqme

value:
Hi, this is my recent work of several months of Agentic Engineering.
So the background of this is I like building toolings / compiler, but never had the time since I run startups. So since the coding AI becoming better I started to build something that I for a long time wanted to build: own vm / runtime
So, the problem I want to solve is that I like Typescript and I like go-lang concurrency model, and there is no attempt building typescript-like runtime so I give it a shot.
It is using reactor model with io thread-pool and worker-threadpool, Stack based VM, thin task model with small initial stack like go.
The Idea is all execution is task, whenever a task is run, it will run until suspension point (channel, io, sleep, etc) no task can run more than 10 ms, it will be preempted at safepoint. I try to make task switching as cheap as possible
For JIT and AOT I use cranelift to generate machine code from SSA. I use prewarming using compile time heuristic and JIT hotpath profiling. It support also AOT. I make so that native code also follow the task model so it has safepoint, suspendable and preemptible.
Still early. Happy to hear feedback.

value: Show HN: Raya – TypeScript-like language with Go-like concurrency model

author: rizqme


value: broyeztony

value: Show HN: Karl, expression-first language (https://github.com/broyeztony/Karl)

author: broyeztony


value: coderredlab

value:
Hi HN,
I built an Android app that bundles a minimal Linux environment and runtime to run OpenClaw locally on-device.
The motivation was simple: I didn’t want to spin up and maintain cloud VMs just to host an AI gateway. Modern Android phones are capable enough, so I experimented with packaging the runtime directly inside the app using proot.
The app installs a bundled Linux rootfs, runs the gateway inside that environment, and exposes the usual integrations (Telegram, Discord, OpenAI-compatible APIs). Everything runs locally on the phone — no external server required.
Some constraints I had to work around:
Android background execution limits
Battery and thermal considerations
File system isolation inside the app sandbox
DNS/network quirks in a proot environment
It’s not meant to replace proper infrastructure, but it works surprisingly well for lightweight, always-on personal setups.
Curious to hear if others have tried similar approaches on Android.
Happy to answer technical questions about the architecture, limitations, or trade-offs.

value: Show HN: Bundling Linux inside an Android app to run OpenClaw

author: coderredlab


value: MauricioML

value:
Hi HN,
I do some retail arbitrage and got incredibly frustrated missing out on massive 90% off glitches. By the time someone posts a deal on Slickdeals or DealNews, bots have already cleared the stock.
I decided to fix my own problem and built Sniper Syndicate. It’s a custom Python Telegram bot that scrapes RSS feeds and Reddit in real-time. Instead of just forwarding links, I wrote some Regex logic to actually extract and calculate the discounts from raw HTML, dropping anything under a 20% true discount and filtering out sweepstakes or "back in stock" spam.
It works beautifully for my own sourcing (it pings me the second a match is found), so I recently packaged the access via Whop: https://whop.com/snyper-sindicate/sniper-syndicate-membershi...
I'm still improving how the bot handles rate limits at scale with aiohttp, so I'd love to hear your thoughts on the scraping logic or any ideas to make the price filters even better!

value: Show HN: I built an async Telegram bot to snipe 80%+ retail price errors

author: MauricioML


value: tstockham

value:
I built Engram because my AI coding agent (Claude Code) has no memory between sessions. Every new session starts from zero. I kept re-explaining the same project context, decisions, and preferences.
Engram is a persistent memory system designed for AI agents. It runs as an MCP server alongside Claude Code, Cursor, or any MCP-compatible client. One command to set up:
```
npm install -g engram-sdk
engram init
```
After that, your agent remembers things across sessions. It stores facts, decisions, preferences, and corrections, then recalls the right ones when they're relevant.
What makes it different from a vector database or a flat MEMORY.md file:
- *Consolidation.* Raw conversation episodes get distilled into structured knowledge automatically, the same way human memory works (episodic to semantic).
- *Contradiction detection.* When a new fact conflicts with an old one, Engram detects it and supersedes the old memory. No stale data.
- *Spreading activation.* Recall doesn't just do vector search. It walks the memory graph through entity and topic connections, surfacing related context you didn't explicitly ask for.
- *ask() over raw recall.* Instead of returning a list of memory objects, `vault.ask()` synthesizes an answer with confidence signals. The agent gets a direct answer, not a pile of results to interpret.
- *checkpoint().* Before context compaction or session end, the agent saves its working memory to the vault. The context window is the most accurate source of truth and the most volatile. Checkpoint preserves it.
On the LOCOMO benchmark (long-conversation memory, from Snap Research): Engram scores 84.5% on 9/10 conversations vs Mem0's published 66.9%, using 30x fewer tokens than full-context injection. A full 10/10 re-eval is running now.
The whole thing is TypeScript, zero external dependencies for the core, SQLite + sqlite-vec for storage and vector search. AGPL-3.0 licensed.
GitHub: https://github.com/tstockham96/engram
Site: https://engram.fyi
npm: https://www.npmjs.com/package/engram-sdk

value: Show HN: Engram – Persistent memory for AI coding agents (open source)

author: tstockham


value: ascarola

value:
I built VerdictMail as a homelab project to explore whether combining
classical email authentication signals with LLM reasoning produces better
threat classification than either approach alone.
It runs as a daemon on Ubuntu, monitors a Gmail inbox via IMAP IDLE, and
processes every incoming message through a multi-stage pipeline:

  RFC 822 parse → whitelist check → enrich → AI analyze → decide → act → audit

The enrichment stage collects SPF/DKIM/DMARC results, DNSBL reputation,
WHOIS domain age, display-name spoofing detection, and URL expansion — then
packages all of that as structured context in a prompt to the LLM. The model
returns a JSON threat assessment with a confidence score and reasoning chain,
which the decision engine maps to one of three IMAP actions: pass, flag
($VerdictMail-Suspect keyword), or move to Junk.
Supports OpenAI, Anthropic, or a local Ollama instance. I run it with
qwen2.5-coder:7b locally for privacy. Full pipeline typically completes in
under 15 seconds with a cloud provider.
Includes a Flask web UI with dashboard, paginated audit log, whitelist
management, in-browser YAML config editor, and a manual test page where you
can paste a raw email and dry-run the full pipeline.
Runs as two systemd services. Tested on Proxmox LXC (unprivileged).
MIT licensed.
Happy to discuss the enrichment → LLM prompt design, the confidence threshold
tuning, or the LXC-specific stop/pause behavior if anyone is curious.

value: Show HN: VerdictMail – IMAP daemon that uses LLM reasoning to catch phishing

author: ascarola


value:
Follow-up to my post 3 days ago. AgentLint went from 10 rules to 42 across 7 packs.
The interesting technical bits since last time:
Stack auto-detection. AgentLint inspects project files (pyproject.toml, package.json, framework dependencies) and activates relevant rule packs. Python pack catches bare excepts, unsafe subprocess calls, SQL injection patterns. Frontend pack checks accessibility (alt text, form labels, heading hierarchy). React
and SEO packs activate when their dependencies are present. No config needed — drop agentlint.yml if you want to override.
All 17 hook events. Claude Code exposes more lifecycle hooks than most people realize: PreToolUse, PostToolUse, Stop, UserPromptSubmit, SubagentStop, Notification, SessionEnd, and 10 others. AgentLint now handles all of them. The interesting one is UserPromptSubmit — you can validate what the user asks before the
 agent acts on it.
File content caching for diffs. PreToolUse caches the file's content before an Edit/Write. PostToolUse receives the "before" snapshot so diff-based rules work (e.g., detecting when error handling gets removed from a file).
Binary resolution problem. Claude Code runs hooks via /bin/sh with a minimal PATH. On macOS, pip installs console_scripts to /Library/Frameworks/Python.framework/Versions/3.13/bin/ which isn't on that PATH. shutil.which() fails. The fix was a 5-step probe chain: PATH → ~/.local/bin (pipx) → uv tools dir →
sysconfig.get_path("scripts") → python -m fallback. The sysconfig call is the key — it returns exactly where pip put the binary. Also had to add __main__.py since the python -m fallback was broken without it.
Quality pack (always-active). Validates commit messages against conventional commits format. Detects dead imports. Warns when try/except or .catch blocks get removed entirely (not refactored — removed). Injects a self-review prompt at session end. Tracks token budget across the session.
741 tests, 96% coverage. Still Python 3.11+, still no dependencies beyond click and pyyaml.
The custom rules API hasn't changed — subclass Rule, implement evaluate(), drop a .py file. But the engine now provides richer context: file diffs, prompt content, subagent output, notification metadata.
https://github.com/mauhpr/agentlint

value: Show HN: AgentLint v0.5 – 42 rules, stack-aware guardrails for AI agents


value: starwildcard

value: Show HN: Magnetic Tower of Hanoi – 8 disks = 2026 moves (the year)

author: starwildcard


value: indybonez

value: A VS Code extension that exposes an MCP (Model Context Protocol) server, allowing AI agents like Claude Code and Claude Desktop to control VS Code's debugger. Language-agnostic — works with any debug adapter (Node.js, Python, C++, Go, Rust, Java, etc.).

value: Show HN: Debugger MCP for VS Code

author: indybonez

title: Show HN: Debugger MCP for VS Code


value: Show HN: SEOBot – open-source AI SEO tool (keyword research, content gen, audit)


value: elxreno

value: Show HN: MSI GPU Mux Switcher for Linux via UEFI Vars and EC Trigger

author: elxreno


value: Alex-Hosein

value:
Attacks targeting the orchestration layer (e.g., Kubernetes control planes, cloud APIs) are stealthy and often bypass conventional security mechanisms. These attacks can exploit API misconfigurations, escalate privileges, and compromise infrastructure.
We built InferShield, an open-source Proof of Concept, to explore early detection of such threats. InferShield uses session tracking and event correlation to identify abnormal sequences of orchestration-layer activity.
Example Attack Detection:
An attacker uses a compromised API token to inspect deployment configurations, escalate privileges via role misconfiguration, and push modified manifests to introduce malicious containers. InferShield alerts by recognizing the unusual API call sequence.
Limitations:
- It's in-memory only, which limits scalability
- Detection is limited to rule-based patterns and cannot adapt to unknown attack vectors
- This is an experimental tool and should be treated as a starting point, not a solution
We're seeking feedback, contributors for further development, and insights from security researchers on how to strengthen this approach.

value: Show HN: InferShield – A Lightweight Orchestration-Layer Attack Detector (POC)

author: Alex-Hosein


value: coolwulf

value: I have been working on this project relentlessly in the last a couple weeks, mainly is for my own usage case since I'm relying on a lot of browser automation. So my focus is more on browser CDP tool usage than just IM integration. Please enjoy and give me some feedback. Thank you!

value: Show HN: OpenClaw alternative written in Golang and talk with you in voice

author: coolwulf


value: lewKcoder

value: Show HN: Acube – Rust framework where forgetting security is a compile error

author: lewKcoder


value: sachaa

value:
I was wondering... why do we need a Mac Mini, a VPS, or a Docker container to run OpenClaw?
Your browser already has a secure sandboxed OS, a database, a filesystem, and a JS engine. What if we just... used those?
So I built OpenBrowserClaw inspired by the simplicity of NanoClaw but running entirely in a browser tab.
- Claude API with full tool-use loop
- Shell commands in a v86-emulated Alpine Linux (yes, a Linux VM in WASM, in your browser)
- File I/O via OPFS
- Data persistence in the browser local storage
- Telegram integration over plain HTTPS
- Zero runtime dependencies
No server. No deploy. No infra. Open a tab, paste your Claude API key, start chatting.
It even works as a PWA, install it on your phone if you want.
The whole thing is MIT-licensed and open source:
https://github.com/sachaa/openbrowserclaw
Or just try it right now without cloning anything:
https://www.openbrowserclaw.com/
Sometimes the best server is the one you already have open.

value: Show HN: OpenBrowserClaw – No Mac Mini. No VPS. No Cloud Deploy. Just Open a Tab

author: sachaa


value:
Hey HN,
We've been heads down building Coasty for the past few months and wanted to share a milestone, we just achieved state-of-the-art results on OSWorld, the most comprehensive benchmark for computer-use agents.
For those unfamiliar, OSWorld tests whether AI agents can actually use a computer the way a human does navigating real desktop environments, clicking through UIs, filling out forms, managing files across apps.
We're building an agent execution platform for computer-use AI. Think of it like Vercel but for AI agents that operate full desktop environments. You give Coasty a task, and it spins up a sandboxed environment where an agent can see the screen, move the mouse, type, and complete end-to-end workflows things like filing expenses, canceling subscriptions, filling out insurance forms, or navigating legacy enterprise software.
Why this matters
Most "AI automation" today is really just API glue between apps that have APIs. But the vast majority of business workflows still live in UIs that were designed for humans, healthcare portals, government forms, internal tools that will never get an API. Computer-use agents unlock automation for all of that.
What's next
We're opening up early access. If you're dealing with painful, repetitive computer workflows (especially in healthcare, insurance, legal, or ops), we'd love to talk.
Happy to answer questions about our approach, the benchmark, or anything else.

value: Show HN: Coasty.ai – We just hit SOTA on OSWorld (computer-use agent benchmark)


value: Show HN: Gridl – A daily block puzzle game


value:
I kept rewriting the same JSON normalization glue for every side project. Weather APIs return different field names, crypto APIs have inconsistent structures, news APIs format dates differently — and you end up writing adapters for all of it before you can even start building.
Sprime is a unified API gateway that sits in front of 15+ data providers and returns everything in the same JSON shape, every time.
One API key, consistent responses, automatic provider failover if something goes down.
Endpoints live now: weather, crypto, news, forex, air quality, geocode, IP lookup, timezone, holidays, webhooks.
Free tier is 500 req/day. Would love feedback from the HN crowd on pricing, missing endpoints, or anything that seems off.

value: Show HN: Sprime – weather, crypto, news, forex all normalized to one JSON schema


value:
I’ve just released Goxe v1.4.0. After the last update, I’ve been obsessed with squeezing every bit of performance out of Go.
The Big Update: Offline Normalization (-brew)
I added a new mode to process and normalize legacy logs that were sitting on disk before Goxe was installed. It clusters similar messages, reduces storage footprint, and ships metrics to a remote server.
The Engineering Win:

    Allocations: I managed to reduce the overhead from 2 allocs/op to just 1 per log line using unsafe zero-copy string conversions and bufio.Scanner optimization.

    The Goal: I’m currently refactoring the core pipeline to hit 0 allocations in the next cycle.

    Performance: Still hitting 19k logs/s on an old i5-8250U @ 3.40 GHz with a minimal RAM footprint.

Why use it? If you have massive log files cluttering your disk, -brew will normalize them into a structured summary ([name]_[date]_normalized.log), saving space and giving you clear stats (Count, First/Last seen) without killing your CPU.
I’d love to hear your thoughts on the zero-copy approach.
Repo: https://github.com/DumbNoxx/goxe

value: Show HN: Goxe – Fast log clustering on an i5 (Reduced to 1 alloc/log, road to 0)


value: ajithmanmu

value: Show HN: MeterFlow – Usage-based billing engine with fraud detection

author: ajithmanmu


value: Show HN: Tandem is a CLI to assist in reading Latin texts


value: allanclempe

value:
I run a small dev consultancy and got sick of the end-of-week "what did I actually work on?" timesheet reconstruction. So I built Clocktopus.
It generates timesheets from your git commits. The idea is simple: if you follow good development practices: focused work, regular commits, proper git hygiene, accurate time tracking becomes a natural side effect.
Works with default working hours/timezone settings that Clocktopus uses as a baseline, but if you have flexible hours, you can send a signal from the CLI when you start/finish your day. No browser tabs, no context switching.
It's built for developers and small consultancies who bill hours but hate tracking them. Currently in free beta.
For more information: https://clocktopus.app/docs
Happy to answer questions about the approach or the edge cases (there were many).

value: Show HN: Clocktopussheets generated from your Git commits

author: allanclempe


value: syumpx

value: Show HN: Sayou: Open-source agent workspace with versioned files and MCP tools

author: syumpx


value: kadeus

value: Show HN: Convert Audio to Text – NeatScribe

author: kadeus


value: CzaxTanmay

value:
Hi HN,
I’ve been building Panther, a cross-platform scripting language designed specifically for cybersecurity workflows and automation.
Panther focuses on making common security tasks simple, readable, and fast without relying on complex shell pipelines or large scripting setups.
The language runtime is written in Go, and Panther currently runs on Windows and Linux, with a dedicated VS Code extension for development.
Why Panther?
Cybersecurity workflows often require combining multiple tools and languages:
Bash scripts
Python utilities
CLI scanners
manual command chaining
Panther explores a different approach — a domain-specific scripting language with built-in security capabilities and a clean syntax designed for automation and learning and real world cybersecurity programming.
Key Features --
Cross-platform (Windows & Linux)
Built in Go for speed and reliability
VS Code extension with language support
60+ cybersecurity-based commands
16 core language keywords
Simple and readable syntax
Fast execution
Designed for ethical and legal security testing
Example Code
Compute("Hello");
Phone_Info("+CountryCodeMobileNumber");
name = Accept("Hello, enter your name: ");
Print("Hello " + name);
(Compute() can also be used as output instead of Print().)
The goal is to make scripts easy to read while keeping security workflows concise.
Architecture --
Execution engine: native interpreter
Editor support: VS Code extension
Built-in commands: cybersecurity-focused primitives
Project Goals
Simplify cybersecurity automation
Provide a beginner-friendly entry into security scripting
Reduce dependence on complex multi-tool setups
Create a focused DSL for ethical security workflows.
Learn Panther through it's GitHub README.
Feedback Welcome
I’d really appreciate feedback on:
Language design
Command structure
Developer experience
Real-world security use cases
GitHub:
https://github.com/CzaxStudio/Panther
Website --
https://pantherlang.pages.dev/
Thanks for reading — feedback is very welcome.

value: Show HN: Panther – a cross-platform cybersecurity scripting language

author: CzaxTanmay


value: ramsbaby-dev

value:
I run a local AI assistant (OpenClaw) on a Mac mini. When it crashes, I wanted it to fix itself automatically. So I built a 4-tier recovery system:
Level 1 → launchd auto-restart (seconds)
Level 2 → watchdog health check every 60s
Level 3 → Claude Code AI diagnosis + repair (fires after 30+ min failure)
Level 4 → Discord/Telegram human escalation
The system looked great on paper. But v3.0.0 had a critical bug: Level 2 logged "Escalating to Level 3..." but never actually called the script. The chain was broken at the most important handoff — silently, for weeks.
v3.1.0 fixes this plus adds chain verification in the installer so each level is tested end-to-end before calling it done.
The meta-lesson: "I have monitoring" ≠ "my monitoring chain is actually connected."

value: Show HN: 4-tier self-healing AI agent (was silently broken for weeks)

author: ramsbaby-dev


value:
I run a local AI assistant (OpenClaw) on a Mac mini. When it crashes, I wanted it to fix itself automatically. So I built a 4-tier recovery system:
Level 1 → launchd auto-restart (seconds)
Level 2 → watchdog health check every 60s
Level 3 → Claude Code AI diagnosis + repair (fires after 30+ min failure)
Level 4 → Discord/Telegram human escalation
The system looked great on paper. But v3.0.0 had a critical bug: Level 2 logged "Escalating to Level 3..." but never actually called the script. The chain was broken at the most important handoff — silently, for weeks.
v3.1.0 fixes this plus adds:
- Chain verification in the installer (each level is tested end-to-end)
- Graceful .env loading so Level 3 doesn't die silently without API keys
- Watchdog Catch-up mode for missed intervals
GitHub: https://github.com/Ramsbaby/openclaw-self-healing
The meta-lesson: "I have monitoring" ≠ "my monitoring chain is actually connected." Testing each component starts is not the same as testing the system works end-to-end.

value: Show HN: A 4-tier self-healing system for local AI agents (was silently broken)


value: DavisGrainger

value: Show HN: ZuckerBot. API and MCP server for AI agents to run Meta/Facebook ads

author: DavisGrainger


value: Show HN: LucidExtractor – AI web scraper that understands plain English


value: pruetj

value: Say what needs to be said. You can be anonymous or not. The site is meant to be simple, private, and at cost.

value: Show HN: Say What You Should Have

author: pruetj

title: Show HN: Say What You Should Have


value: varmabudharaju

value: Show HN: Chorus –Let users improve the LLM without their data leaving the device

author: varmabudharaju


value:
Hi HN,
Open-sourced my complete AI-native architecture series from a solo builder project (spare time).
4 articles (EN/ZH) covering:
- Constrained DSL for reliable LLM decisions
- 60/40 → 90/10 AI-driven development workflow
- "Boring" hybrid agent architecture
- Low-cost multi-vendor cloud scaling
Real scale: 28 repos, 538k LOC, 3k+ users, low four-digit RMB yearly infra.
Repo: https://github.com/myinvestpilot/ai-architecture
Pure sharing, no promo. Feedback, critiques, or your solo AI-native experiences welcome!
Thanks

value: Show HN: AI-Native Architecture Series (Open-Source)


value: dankrieg

value:
GrowthClaw is an open source workflow pack and skill that connects to OpenClaw and provides it with a structured marketing runtime.
It adds an explicit operating layer around the agent by modeling product context, generating strategy versions, producing prioritized tasks, enforcing approval gates, executing work, and evaluating outcomes through controlled state transitions. Workflows are declared in YAML and all entities such as tasks, artifacts, evaluations, and strategy revisions are persisted in SQLite, making the system inspectable and replayable.
Each agent role follows a defined rubric, and execution results feed into a scheduled strategy evolution loop that reassesses context and prior performance before proposing new work. Nothing runs without approval, but iteration continues autonomously based on observed outcomes and stored state.
The goal is to explore whether growth can be delegated to an agent operating inside a constrained feedback system, where adaptation emerges from measurable results and decisions are governed by explicit rules rather than informal adjustments.

value: Show HN: GrowthClaw, a workflow pack for deterministic growth execution

author: dankrieg


value: shiplocal

value: Show HN: AI Localization for App Store ASO

author: shiplocal


value: paweljanda

value:
Hi! We open-sourced mt_audio, a stream-based audio module for Flutter that wraps just_audio + audio_service behind a single facade.
We built this because in multiple production apps (podcast/radio/audiobook-like flows) we kept re-implementing the same glue: background playback, notifications, queue handling, stream/state wiring, and integration edge cases. The goal is a small dependency that gives a consistent API and reduces app-level complexity (no required external state management).
Key features:
background playback + system notifications
queue management (playlist-first workflows)
Android Auto & Apple CarPlay support behind the same facade
example app + ready UI widgets (Now Playing / controls)
Feedback welcome — especially on API shape, missing edge cases, and docs/examples.

value: Show HN: A stream-based Flutter audio module with CarPlay/Android Auto

author: paweljanda


value: koalux

value:
I built this as a weekend project thinking about what I could do with emojis. The whole thing is nothing more than a single HTML file with some JavaScript.
Check it out, and maybe tweak the configs to make the engine more fun (you can change the speed, particle count, and colors pretty easily).
Live demo: https://j-ncel.github.io/Spacemoji/
Interact with this by tapping or holding.

value: Show HN: Spacemoji – 3D emoji-filled space warp simulation in a single HTML file

author: koalux


value: asim

value:
Hey all
I'm working on this new app platform that's Ads and algorithm free. Looking for feedback and review to see if it's going in the right direction. I'm using it daily but trying to figure out how to make it something useful for others and sustainable as products like Kagi.
https://mu.xyz

value: Show HN: Review my new app platform Mu

author: asim

title: Show HN: Review my new app platform Mu


value: Show HN: AI-nexus – Semantic router that cuts Claude Code token usage by 84%


value: vicioussquid

value: Show HN: Optional AI accelerator support without PyTorch (ONNX and NumPy)

author: vicioussquid


value: Was interesting using the latest Gemini to write a single file HTML vibe coded WebGL game, no servers or self hosted external dependencies, just a few CDN files and high scores in localStorage only.

value: Show HN: Aussie Meme Boss Rush – 1 day Vibe Coded WebGL single file HTML game


value: herbertverdida

value:
Hi HN.
I've been building automation tools this past year. One problem kept happening. Everything works fine locally, but once deployed to AWS or other cloud providers, sites start blocking.
Most AI agents run from datacenter IPs, and those IPs are already flagged by many websites.
So we decided to build something for it.
Aluvia lets agents connect using mobile carrier IPs instead of datacenter IPs. The idea is simple. If traffic looks more like real mobile users, it gets blocked less often.
We packaged it as:
@aluvia/sdk
@aluvia/cli
@aluvia/mcp
It works with Playwright, Puppeteer, Axios, Selenium, and similar tools.
We're not trying to compete with the big proxy companies. We just wanted something more developer-friendly and easier to integrate, especially for AI builders.
It's still early, so I'd really appreciate feedback. Curious if others here faced the same issue, or solved it differently.
Website: https://www.aluvia.io/
Happy to answer technical questions.

value: Show HN: Mobile IPs for AI agents that keep getting blocked

author: herbertverdida


value: malwaregeeeek

value: Sira redefines the experience of booking a flight. We are an AI native flight booking app empowering users to book a flight in 1 click

value: Show HN: Sira,reinventing fligh booking experience (travelwithsira.com)

author: malwaregeeeek


value:
I've been working on SKALP, a hardware description language written in Rust, and just shipped v0.1.1 with pre-built binaries for Linux, macOS, and Windows.
The core idea: hardware design tools throw away too much intent too early. You write a state machine, but by the time it hits synthesis, the tool only sees a bag of gates and has to reverse-engineer what you meant. SKALP keeps that intent through four intermediate representations — from a high-level algorithmic IR down to gate-level netlist — so each compilation stage has the context it needs to make good decisions.
The thing I'm most interested in technically is clock domain crossings as compile-time types. If you've worked on multi-clock designs, you know CDC bugs are some of the hardest to find. In SKALP, clock domains are parameterized types (think Rust lifetimes but for clocks), so connecting signals across domains without a proper synchronizer is a compiler error, not a simulation surprise at 3am.
Other pieces that might be interesting: GPU-accelerated fault simulation via Metal (~11M fault-cycle sims/sec on M4 Max), integrated P&R targeting iCE40 FPGAs, built-in formal verification, and ISO 26262 FMEDA generation. There's also a VSCode extension with an integrated waveform viewer, a debug adapter with cycle-level stepping and conditional breakpoints, and testbench integration through the test explorer. The syntax is expression-based and Rust-influenced — traits, generics, pattern matching.
It's still early. The iCE40 backend works but coverage is limited, and the GPU path is macOS-only for now. The codebase is ~290K lines across 23 crates.

  Website: https://mikaana.com/projects/skalp/
  GitHub: https://github.com/girivs82/skalp
  Tutorial (10 chapters): https://mikaana.com/tutorial/
  Blog post on the IR pipeline: https://mikaana.com/blog/skalp-ir-pipeline/

value: Show HN: Skalp – An intent-driven hardware language with clock domains as types


value: iivyvii

value: Show HN: Bibabo – Gamified AI-first coding education

author: iivyvii


value: maneeshthakur

value:
Most repos accumulate .md files that nobody ever reads — CONTRIBUTING.md, ARCHITECTURE.md, docs/API.md — because they were never linked from the root README. They exist but are invisible to anyone navigating the project.
I built a small CLI tool that scans a repo, checks which .md files are actually referenced in the root README, and reports the rest as "isolated". It also has an interactive fix option that appends the missing links directly into your README, and a GitHub Action if you want to enforce it in CI.
Single Python file, no config, runs offline. Would love feedback on whether the approach makes sense or if there are edge cases I haven't considered.

value: Show HN: Find Markdown files in your repo that aren't linked from the README

author: maneeshthakur


value: peonai

value: Show HN: Swarm AI – Shared memory layer for AI agents (self-hosted, open source)

author: peonai


value: pmatos

value: I built an interactive timeline showing the lives and connections of composers and performers, organized by instrument. Lifetime bars are color-coded by role, and curves show teacher-student and family relationships. Switch between piano, violin, and trombone, click anyone for their bio and portrait. It's a static React site with all data in JSON, so contributions are just a PR away. See https://github.com/pmatos/music-timeline

value: Show HN: Musiker.page – Interactive timeline of musicians by instrument

author: pmatos


value: mikesol

value:
My goal is to reimplemenet a hefty chunk of TypeScript in TypeScript using a DSL that resembles TypeScript. But instead of immediate execution, what you get is a serializable program represented as a directed acyclic graph that can be mutated à la Nim or Haxe via a query language.
I'm not quite sure why I'm doing this, but two thoughts emerge as I tinker:
1. It's fun to explore a "boil the ocean" task with an LLM. Writing a mini TypeScript in TypeScript forces you to confront lots of design choices during the build-out that improve the core but require small, substantive changes on the entire plugin ecosystem. sed can't handle this, but a model like Sonnet can. And as the foundation gets better, I get more bullish about one-shotting entire libraries as plugins.
2. I think that something like mvfm will eventually power arbitrary 0-trust distributed programs. For example, take the case of a vibe-coded app that is otherwise frontend-heavy but uses a LLM, Stripe, and a DB. Writing parts of the program in a serializable DSL allows automatic deployment of parts of it to other targets. It also allows an untrusted environment, like a browser, to execute logic that touches sensitive things like DBs and send the actual mutations to a lightweight proxy that checks its integrity against a set of known inputs.
If you're nerd-sniped, I'd love help (a) trying to break it; (b) improving the core; and/or (c) implementing more libs as plugins.

value: Show HN: Tagless final DSL for deterministic TypeScript programs

author: mikesol


value: sasponn

value:
LabhLabs is a live shadow trading and AI orchestration arena for Indian markets.
It enables strategies to run on real time market data using paper capital, mirroring live conditions without deploying actual funds. This allows models to be evaluated against execution aware realities such as latency, slippage, and regime shifts not just historical simulations.
Beyond simulation, LabhLabs functions as an orchestration and governance layer for multiple AI trading agents.
In contrast to Alpha Arena, LabhLabs is implemented for Indian markets, where data is inherently fragmented and less standardized than US market feeds. The framework embeds structured risk controls prior to any live capital deployment.

value: Show HN: Labhlabs – What Happens When LLMs Trade the Indian Market?

author: sasponn


value: shahidsj

value: Most online PDF mergers upload your sensitive documents to their servers. I built this utility to merge PDFs directly in the browser for better privacy and speed. No sign-up, no file size limits, and no data storage. Looking for feedback on the UI/UX!

value: Show HN: Fast, browser-side PDF merger with no file uploads to server

author: shahidsj


value: tjindl

value:
Hi HN,
I'm excited to share a project I've been working on called Code Lantern. It's a self-hosted tool designed to help you visually explore and understand codebases.
Whenever I jump into a new codebase (or return to one of my own after a few months), I often find myself spending hours just tracing function calls, mapping out dependencies, and trying to build a mental model of how everything fits together. I wanted a way to instantly generate a high-level architectural view, but I didn't want to upload my code to a third-party server to get it.
So, I built Code Lantern. You run it via Docker, point it at any local project folder, and it generates:
Interactive Dependency Graphs: Visual maps of how files and functions connect, powered by Cytoscape.js.
Architecture Maps: Tree diagrams breaking down your file and function structures.
Complexity Heatmaps: It uses AST to calculate cyclomatic complexity scores, helping you spot technical debt at a glance.
AI Deep Dives (Optional): If you click on any function, it can generate a description of what it does, its inputs/outputs, and call relationships.
How it works under the hood: The backend is built with FastAPI and uses Tree-sitter for accurate AST parsing (supporting Python, JS/TS, Java, C++, and Rust). It extracts functions, classes, imports, and resolves call relationships locally. The frontend is built in React.
Privacy and Setup: Privacy was my main priority. The tool runs locally in Docker and mounts your project folder strictly as read-only. Your code never leaves your machine.
The core analysis, graphs, and heatmaps work completely offline without any API keys. If you want to use the AI "Deep Dive" descriptions, you can just plug in your own API key in the .env file (it supports Groq, OpenAI, Anthropic, Gemini, OpenRouter, or Cohere). The API calls are optimized and will take least amount of tokens possible.
It’s open source under the MIT license. You can spin it up with a single ./run.sh script.
I'd love for you to try it out on one of your projects and let me know what you think, or what features would make navigating new codebases easier for you. Happy to answer any questions and hear your feedback!
Repo: https://github.com/Tjindl/code-lantern

value: Show HN: Code Lantern– A self-hosted, local code-analysis and visualization tool

author: tjindl


value: pabloschz

value: Hey, I'm Pablo and I feel like we are wasting our lives scrolling on social media. Sadly they are somehow necessary, and deleting them is not the solution but intentional usage is. That's why I built this app. I'm planning to go deep and improve it as much as possible, as I think this is one of the biggest problems we're facing as a society right now. It's free to try for a few days, hope you like it.

value: Show HN: I made and app to stop living on autopilot

author: pabloschz


value: gisverygood

value:
I realized I avoid hard decisions/tasks like a Damocles sword.
Instead, I:
- change UI details
- reorganize lead lists
- do “productive” nonsense
Zero real progress.
So I built DoFast.
It tells me the best action I need to take right now to actually move the project forward.
It’s free. Yes fr.

value: Show HN: DoFast – I built a tool that shows me my next best action

author: gisverygood


value: xavpoon

value: Show HN: Mellon – Free local speech-to-text for Mac with phonetic corrections

author: xavpoon


value: Sechele

value:
Launching for the full public on 17th May 2026;
Union is the AI sales platform built for companies that want to grow faster without growing their workload. Get on the waitlist now.

value: Show HN: Launching for the full public on 17th May 2026

author: Sechele


value: yunusemregurlu

value:
Hi HN,
I've been using Claude Code heavily for autonomous agent workflows and hit
a consistent pain point: zero visibility into what's running, what's stuck,
and how close to context overflow each session is.
So I built claudedash. One command:

    npx -y claudedash@latest start

Opens a local dashboard on port 4317. It passively watches ~/.claude/tasks/
(the files Claude Code writes natively) and renders:
- Live Kanban: pending → in_progress → completed → blocked
- Context health % per session (last-message tokens / model max)
- Worktree observability (per-branch agent status)
- Plan Mode: reads queue.md, renders dependency graph, syncs execution.log
- MCP server: so Claude can query its own dashboard
- Cost tracker, hook event log, session history
Technical notes for the curious:
- Fastify + chokidar for the server
- SSE (one shared connection via module-level singleton)
- Server-side mtime-based caching (no unnecessary file reads)
- Static Next.js export, no server rendering
- Zero telemetry, fully local
The context health feature was trickier than expected — the naive approach
of summing all input_tokens gives wildly wrong numbers. The correct approach
is using only the last message's token counts.
180 commits, MIT license.
GitHub: https://github.com/yunusemrgrl/claudedash
Website: https://yunusemrgrl.github.io/claudedash/
Happy to answer questions about the implementation or design decisions.

value: Show HN: Claudedash – real-time local dashboard for Claude Code agents

author: yunusemregurlu


value: sfluecki-dev

value:
I built BUDGT in 2013 as a broke student who needed one answer: "how much can I spend today without going broke this month?" It divides your monthly budget into a daily allowance — one number, updated in real time as you log expenses.
13 years and thousands of users later, I rebuilt the whole thing from scratch. The original Objective-C app couldn't support what users were asking for (analytics, category budgets), so I moved to Flutter and rewrote every screen.
What's different:
- Full redesign with a modern UI
- Analytics: spending pace, month-over-month, day-of-week patterns, top expenses
- Category targets: set limits per category, not just an overall budget
- Category drill-down: see exactly where money goes within each category
What hasn't changed:
- 100% offline. No account, no cloud, no bank connection, no tracking.
- All data stays on the device. I literally cannot see your data.
- Same daily budget concept — one number, color-coded feedback.
The hardest part was migrating existing users' Core Data (SQLite) to the new Drift database without losing any records. Existing users get the update automatically and see a migration flow that moves their entire history.
Happy to discuss the technical side (Flutter architecture, Core Data migration, App Store continuity with a full rewrite) or the product side.
iOS only: https://apps.apple.com/app/id580812126

value: Show HN: I rebuilt my 13-year-old budgeting app from scratch in Flutter

author: sfluecki-dev


value: ethanplanva

value:
Hi HN,
I’ve been working on a tool called AI Timeline Maker (https://timeline-maker.org) to solve a workflow problem I kept running into.
Creating timelines for project roadmaps, research, or historical topics is usually very manual. Most tools require adding events one by one, which becomes slow when working with long documents or structured content.
The idea behind this tool is simple:
Instead of starting from a blank canvas, you start with content. You can input text or upload a document, and the AI generates a structured timeline draft automatically. After that, everything is fully editable in a visual editor.
I’m especially interested in feedback on:
- Whether AI-generated timelines are actually useful in real workflows
- The balance between automation and manual control
- Potential use cases I may be overlooking
Built as a browser-based tool with a focus on speed and usability.
Happy to answer any technical or product questions.

value: Show HN: AI Timeline Maker – turn text and documents into visual timelines

author: ethanplanva


value: niyoseris

value:
Every AI conversation starts from scratch. I've been using OpenClaw, Windsurf, and Gemini interchangeably for months—but none of them aware what we discussed from each other. I have to tell them everything from beginning.
So I built Cerebrun, an MCP server that acts as a persistent memory layer across all of them.
What Cerebrun does:
• Cross-conversation retrieval - Automatically finds relevant snippets from past threads and injects them into current context, even across different LLMs
• 4-layer data model - Not all memories are equal. Layer 0 holds public preferences (coding style, favorite tools, language preference etc.). Layer 3 is an encrypted vault for sensitive data (API keys, credentials). Each layer has its own permission scope.
• Semantic search – pgvector under the hood.
Knowledge entries are auto-embedded, so "I prefer functional programming" surfaces when you ask about error handling—no exact keyword match needed.
• Multi-LLM gateway - Works with OpenAI, Anthropic, Gemini, Ollama Cloud, OpenClaw or anything has agentic skills. Bring your own keys, no vendor lock-in.
Why this matters:
Most memory solutions are either platform-specific (ChatGPT's memory) or require you to manually paste context every time. Cerebrun sits in the middle—your AI tools query it via MCP, and it returns only what's relevant for the current conversation.
Privacy angle:
Built with Rust/Axum. Sensitive data in the vault layer is AES-256-GCM encrypted. Your credentials aren't sitting in plaintext in a database, and the memory layer runs locally—you control the data.
Current state:
MVP is functional
Web Dashboard is active
Roadmap:
Chrome extension to collect data and send it to MCP server from non agentic web pages.
Site: https://cereb.run
Repo: https://github.com/niyoseris/Cerebrun

value: Show HN: Cerebrun – A unified memory for AI assistants (MCP and pgvector)

author: niyoseris


value: ybsoft

value:
Hi HN! I built Sayiir, an open-source durable workflow engine with a Rust core and Python/Node.js bindings.
GitHub: https://github.com/sayiir/sayiir
The problem: most workflow engines (Temporal, Airflow, Prefect) require heavy infrastructure, custom DSLs, or replay-based execution that forces determinism constraints on your code. Replay means re-executing your entire workflow history on every recovery — and you can't freely call external APIs or use arbitrary libraries without careful wrapping.
Sayiir takes a different approach: continuation-based execution.
- On crash recovery, it resumes from the last checkpoint — not from the beginning. No replay overhead.
- No determinism constraints. Your tasks can call any API, use any library. No purity rules, no sandboxing.
- No DSL. Workflows are composed with native language constructs — a workflow! macro in Rust, a fluent builder in Python/TypeScript.
- Pluggable persistence. PostgreSQL backend is stable, codec layer supports JSON or zero-copy binary (rkyv).
Architecture: the core is a graph-based execution engine in pure Rust (hexagonal architecture). Python bindings via PyO3/maturin, Node.js via NAPI-RS. Everything is stable — core, Python, Node.js, and Postgres backend.
I chose continuation-driven over replay-driven because replay engines pay a growing cost as workflow history lengthens, and they push complexity onto developers (determinism rules, versioning). Continuations checkpoint state at each step boundary, so recovery is O(1) — just deserialize and go.
Try it live in the playground: https://docs.sayiir.dev/playground/
Docs: https://docs.sayiir.dev
crates.io: https://crates.io/crates/sayiir-runtime
Discord: https://discord.gg/A2jWBFZsNK
MIT licensed. Looking for contributors, early adopters, and feedback. Happy to answer any questions about the architecture or tradeoffs.

value: Show HN: Sayiir – Durable, simple, workflow engine in Rust, no replay

author: ybsoft


value: vinitmaniar

value:
We built a reconciliation engine for complex transaction matching.
But finance teams kept asking us something simpler:
“Can you just give us a clean tool for bank reconciliation?”
So we did.
Today we’re launching CleverBalance — a self-serve bank reconciliation tool for finance teams.
- Upload bank statement.
- Upload ledger.
- Auto-match transactions.
- Review matched & unmatched.
- Download report.
No implementation project.
No sales calls.
No per-reconciliation billing.
If you reconcile every month in Excel, this should save you hours.
It’s built on top of our experience running Cointab (custom reconciliation software used for high-volume matching), but stripped down for teams that just want to close books faster.
14-day free trial. No credit card.
Would love feedback from:
- Controllers
- Early-stage startup finance teams
- CPA / accounting firms

value: Show HN: CleverBalance – Automated Bank Reconciliation

author: vinitmaniar


value: crosschainer

value: Show HN: I curated 10 builder opportunities this week (signals and MVP specs)

author: crosschainer


value: niuexa

value:
Hi HN, I wrote a book on the Model Context Protocol (MCP) – the open standard from Anthropic that lets AI agents connect to external tools and data sources.
I'm an RPA/automation practitioner (CEO of Niuexa, LinkedIn Learning instructor) and I noticed there was no comprehensive resource covering MCP architecture, security patterns, and enterprise deployment strategy. So I wrote one.
The book covers:
- MCP architecture deep dive (servers, clients, hosts, transport layers)
- 20-point security checklist for MCP deployments
- EU AI Act compliance for agentic systems
- Real-world breach timeline from 2025
- Enterprise integration patterns
- Multi-agent orchestration
I used Claude Code to help with the writing and production workflow – the whole pipeline from research to KDP publishing is automated with Python scripts.
Happy to answer questions about MCP, AI agent architecture, or the book production process.

value: Show HN: The MCP Blueprint – First Comprehensive Book on Model Context Protocol

author: niuexa


value: MdSadiqMd

value:
It takes an input video and converts it into H.264/Opus RTP streams that you can blast at your video call systems (WebRTC, SFUs, etc.). It also injects network chaos like packet loss, jitter, and bitrate throttling to see how things break
It scales from 1 to n participants, depending on the compute and memory of the host system
Best part? It’s packaged with Nix, so it builds the same everywhere (Linux, macOS, ARM, x86). No dependency hell
It supports both UDP (with a relay chain for Kubernetes) and WebRTC (with containerized TURN servers). Chaos spikes can be distributed evenly, randomly, or front/back-loaded for different test scenarios. To change this, just edit the values in a single config file

value: Show HN: Chaos Monkey but for Audio Video Testing (WebRTC and UDP)

author: MdSadiqMd


value: SPQRK

value: Show HN: PhraseVault – Desktop text expander, one-time $29 license, source avail

author: SPQRK


value: ronfriedhaber

value: Show HN: Performant, cross-device analytical processing research with tinygrad

author: ronfriedhaber


value: Interactive timeline of every major Large Language Model. Filterable by open/closed source, searchable, 54 organizations tracked.

value: Show HN: AI Timeline – 171 LLMs from Transformer (2017) to GPT-5.3 (2026)


value: Sourabhsinr

value:
Hey HN,
We’re building Elev8or a structured creator marketplace designed to make brand–creator collaborations more predictable.
The problem we saw:
Most influencer marketing is still manual, trust-based, and unstructured. Brands negotiate individually, creators struggle to prove credibility, and performance tracking is fragmented.
What we’re doing differently:
- Verified creator profiles
- Structured collaboration flows (Posts, Collab Campaigns, Deals, etc.)
- Clear usage rights & deliverables
- Escrow-backed payments
- Multi-creator workflows
We’re early and would genuinely appreciate feedback from this community.
What would you improve or challenge in this model?

value: Show HN: Elev8or - A structured creator marketplace for brands

author: Sourabhsinr


value: Tippel

value: Show HN: I built a tool that generates and deploys websites in ~24h

author: Tippel