Show stories

The goal is to have a pixel, mod-friendly perfect recreation of Wolfenstein 3D in Rust.

The article describes the development of SmartMan, an open-source command-line interface (CLI) tool that provides various AI-powered features to enhance productivity and task automation. The tool leverages natural language processing and machine learning to enable voice commands, summarization, and other intelligent capabilities.

I downloaded the MSHA's (Mine Safety and Health Administration) public datasets and create a visualization of all the mines in the US complete with the operators and details on each site.

Hey HN,

I built Rigour, an open-source CLI that catches quality issues AI coding agents introduce. It runs as a quality gate in your workflow — after the agent writes code, before it ships.

v4 adds --deep analysis: AST extracts deterministic facts (line counts, nesting depth, method signatures), an LLM interprets what the patterns mean (god classes, SRP violations, DRY issues), then AST verifies the LLM didn't hallucinate.

I ran it on PicoClaw (open-source AI coding agent, ~50 Go files):

- 202 total findings - 88 from deep analysis (SOLID violations, god functions, design smells) - 88/88 AST-verified (zero hallucinations) - Average confidence: 0.89 - 120 seconds for full codebase scan

Sample finding: pkg/agent/loop.go — 1,147 lines, 23 functions. Deep analysis identified 5 distinct responsibilities (agent init, execution, tool processing, message handling, state management) and suggested specific file decomposition.

Every finding includes actionable refactoring suggestions, not just "fix this."

The tool is local-first — your code never leaves your machine unless you explicitly opt in with your own API key (--deep -k flag).

Tech: Node.js CLI, AST parsing per language, structured LLM prompts with JSON schema enforcement, AST cross-verification of every LLM claim.

GitHub: https://github.com/rigour-labs/rigour

Would love feedback, especially from anyone dealing with AI-generated code quality in production.

Eliezer is ~7K lines of TypeScript, MIT open-source

- PWA for mobile/desktop with push notifications - Self-editing protocol - Builds and displays interactive apps/widgets right in the chat - Task and Crons - "notify if sunny tomorrow at 10am") - Persistent SQLite memory + auto context compaction - Bring your own LLM API key (Kimi/Claude/Grok/etc.) - Full visibility/control - You see all tool calls and can abort in all states

Agent repo: https://github.com/Eliezer-app/eliezer Chat repo: https://github.com/Eliezer-app/clawchat

The chat was originally thought as a plugin for OpenClaw. Ended up writing the agent too.

Hey HN! I built a native macOS desktop client for Hacker News and I'm open-sourcing it under the MIT license.

GitHub: https://github.com/IronsideXXVI/Hacker-News

Download (signed & notarized DMG, macOS 14.0+): https://github.com/IronsideXXVI/Hacker-News/releases

Screenshots: https://github.com/IronsideXXVI/Hacker-News#screenshots

I spend a lot of time reading HN — I wanted something that felt like a proper Mac app: a sidebar for browsing stories, an integrated reader for articles, and comment threading — all in one window. Essentially, I wanted HN to feel like a first-class citizen on macOS, not a website I visit.

What it does:

- Split-view layout — stories in a sidebar on the left, articles and comments on the right, using the standard macOS NavigationSplitView pattern.

- Built-in ad blocking — a precompiled WKContentRuleList blocks 14 major ad networks (DoubleClick, Google Syndication, Criteo, Taboola, Outbrain, Amazon ads, etc.) right in the WebKit layer. No extensions needed. Toggleable in settings.

- Pop-up blocking — kills window.open() calls. Also toggleable.

- HN account login — full authentication flow (login, account creation, password reset). Session is stored in the macOS Keychain, and cookies are injected into the WebView so you can upvote, comment, and submit stories while staying logged in.

- Bookmarks — save stories locally for offline access. Persisted with Codable serialization, searchable and filterable independently.

- Search and filtering — powered by the Algolia HN API. Filter by content type (All, Ask, Show, Jobs, Comments), date range (Today, Past Week, Past Month, All Time), and sort by hot or recent.

- Scroll progress indicator — a small orange bar at the top tracks your reading progress via JavaScript-to-native messaging.

- Auto-updates via Sparkle with EdDSA-signed updates served from GitHub Pages.

- Dark mode — respects system appearance with CSS and meta tag injection.

Tech details for the curious:

The whole app is ~2,050 lines of Swift across 16 files. It uses the modern @Observable macro (not the old ObservableObject/Published pattern), structured concurrency with async/await and withThrowingTaskGroup for concurrent batch fetching, and SwiftUI throughout — no UIKit/AppKit bridges except for the WKWebView wrapper via NSViewRepresentable.

Two APIs power the data: the official HN Firebase API for individual item/user fetches, and the Algolia Search API for feeds, filtering, and search. The Algolia API is surprisingly powerful for this — it lets you do date-range filtering, pagination, and full-text search that the Firebase API doesn't support.

CI/CD:

The release pipeline is a single GitHub Actions workflow (467 lines) that handles the full macOS distribution story: build and archive, code sign with Developer ID, notarize with Apple (with a 5-retry staple loop for ticket propagation delays), create a custom DMG with AppleScript-driven icon positioning, sign and notarize the DMG, generate an EdDSA Sparkle signature, create a GitHub Release, and deploy an updated appcast.xml to GitHub Pages.

Getting macOS code signing and notarization working in CI was honestly the hardest part of this project. If anyone is distributing a macOS app outside the App Store via GitHub Actions, I'm happy to answer questions — the workflow is fully open source.

The entire project is MIT licensed. PRs and issues welcome: https://github.com/IronsideXXVI/Hacker-News

I'd love feedback — especially on features you'd want to see. Some ideas I'm considering: keyboard-driven navigation (j/k to move between stories), a reader mode that strips articles down to text, and notification support for replies to your comments.

Hi Hacker News,

I needed an MQTT client to repeatedly send some commands to devices I build, with Postman-like variable substitutions as I was testing different device IDs with similar commands. MQTT Explorer is nice, but I had to write the commands again and again, with different payloads, and I don't really use the visualization feature. I wanted to save the connection, have a client that opens instantly, parameterizes some common variables, and saves the commands I wrote, so here's MQTT Topic Lab.

MQTT Topic Lab allows you to save your most-used commands, send messages with repetition, and use variables to switch commands on the fly easily. It also has a message viewer so you can also see messages on the broker. After doing the hard work of building your commands, you can export it to share with colleagues so they can get started fast. Also supports keyboard shortcuts if you want to move around like that.

It's built with Tauri (Rust backend, React frontend), so it's cross-platform, and quite fast. Also binaries are quite small (6-7 MB). This is my daily driver so I am going to maintain and update it, and maybe add some features you might want to see in the app. It's coded with Claude, but it's not an "AI-slop" software. The code might be rough on some edges, but it's quite well on how it works.

Looking forward to hear your thoughts, you can check it out at https://github.com/alsoftbv/topic-lab and download built binaries for your device to test it out.

This article provides a brief introduction to using the Claude AI assistant, including how to install it, interact with it, and customize its behavior. It covers the basic usage of Claude and its capabilities as a conversational AI.

I’ve created what I believe a modern comic can look like in 2026. What I’ve built would have required an entire team just a few years ago, but can now be produced by a single person. As a designer and videographer with over 20 years of experience, I know AI is a contentious subject—but for me, the scale of what an individual can now create is incredible.

A Tampermonkey userscript that disables in-browser anti-cheat mechanisms (BlurSpy, honest-responder).

I run a lot of Claude Code and Codex sessions in parallel. I was using Ghostty with a bunch of split panes, and relying on native macOS notifications to know when an agent needed me. But Claude Code's notification body is always just "Claude is waiting for your input" with no context, and with enough tabs open, I couldn't even read the titles anymore.

I tried a few coding orchestrators but most of them were Electron/Tauri apps and the performance bugged me. I also just prefer the terminal since GUI orchestrators lock you into their workflow. So I built cmux as a native macOS app in Swift/AppKit. It uses libghostty for terminal rendering and reads your existing Ghostty config for themes, fonts, colors, and more.

The main additions are the sidebar and notification system. The sidebar has vertical tabs that show git branch, working directory, listening ports, and the latest notification text for each workspace. The notification system picks up terminal sequences (OSC 9/99/777) and has a CLI (cmux notify) you can wire into agent hooks for Claude Code, OpenCode, etc. When an agent is waiting, its pane gets a blue ring and the tab lights up in the sidebar, so I can tell which one needs me across splits and tabs. Cmd+Shift+U jumps to the most recent unread.

The in-app browser has a scriptable API ported from agent-browser [1]. Agents can snapshot the accessibility tree, get element refs, click, fill forms, evaluate JS, and read console logs. You can split a browser pane next to your terminal and have Claude Code interact with your dev server directly.

Everything is scriptable through the CLI and socket API – create workspaces/tabs, split panes, send keystrokes, open URLs in the browser.

Demo video: https://www.youtube.com/watch?v=i-WxO5YUTOs

Repo (AGPL): https://github.com/manaflow-ai/cmux

[1] https://github.com/vercel-labs/agent-browser

micasa is a terminal UI that helps you track home stuff, in a single SQLite file. No cloud, no account, no subscription. Backup with cp.

I built it because I was tired of losing track of everything in notes apps, and "I'll remember that"s. When do I need to clean the dishwasher filter? What's the best quote for a complete overhaul of the backyard. Oops, found some mold behind the trim, need to address that ASAP. That sort of stuff.

Another reason I made micasa was to build a (hopefully useful) low-stakes personal project where the code was written entirely by AI. I still review the code and click the merge button, but 99% of the programming was done with an agent.

Here are some things I think make it worth checking out:

- Vim-style modal UI. Nav mode to browse, edit mode to change. Multicolumn sort, fuzzy-jump to columns, pin-and-filter rows, hide columns you don't need, drill into related records (like quotes for a project). Much of the spirit of the design and some of the actual design choices is and are inspired by VisiData. You should check that out too. - Local LLM chat. Definitely a gimmick, but I am trying preempt "Yeah, but does it AI?"-style conversations. This is an optional feature and you can simply pretend it doesn't exist. All features work without it. - Single-file SQLite-based architecture. Document attachments (manuals, receipts, photos) are stored as BLOBs in the same SQLite database. One file is the whole app state. If you think this won't scale, you're right. It's pretty damn easy to work with though. - Pure Go, zero CGO. Built on Charmbracelet for the TUI and GORM + go-sqlite for the database. Charm makes pretty nice TUIs, and this was my first time using it.

Try it with sample data: go install github.com/cpcloud/micasa/cmd/micasa@latest && micasa --demo

If you're insane you can also run micasa --demo --years 1000 to generate 1000 years worth of demo data. Not sure what house would last that long, but hey, you do you.

I wrote a tiny 5kb library with a new concept for client-side interactivity: reactive hypermedia contexts embedded in HTML.

It looks like this:

  <div hctx="counter">
    <span hc-effect="render on hc:statechanged">0</span>
    <button hc-action="increment on click">+1</button>
  </div>

One feature that stands out is the ability to spread a single context scope across different DOM locations:

    <!-- Header -->
    <nav>
        <div hctx="cart">
            <span hc-effect="renderCount on hc:statechanged">0 items</span>
        </div>
    </nav>

    <!-- Product listing -->
    <div hctx="cart">
        <button hc-action="addItem on click">Add to Cart</button>
    </div>

    <!-- Sidebar -->
    <div hctx="cart">
        <ul hc-effect="listItems on hc:statechanged"></ul>
    </div>

Curious what you think, feedback is welcomed.

We ported pbrt-v4 to Julia and built it into a Makie backend. Any Makie plot can now be rendered with physically-based path tracing.

Julia compiles user-defined physics directly into GPU kernels, so anyone can extend the ray tracer with new materials and media - a black hole with gravitational lensing is ~200 lines of Julia.

Runs on AMD, NVIDIA, and CPU via KernelAbstractions.jl, with Metal coming soon.

Demo scenes: github.com/SimonDanisch/RayDemo

The article discusses the development of Mini Diarium, a simple and lightweight daily journal application that focuses on privacy and minimalism. The project aims to provide users with a straightforward tool to record their daily thoughts and experiences without the clutter of unnecessary features.

The article provides an overview of the open-source Claude programming language, including its key features, syntax, and potential use cases. It discusses the language's design principles, support for concurrency and parallelism, and its integration with popular cloud platforms.

The article introduces Mahler.c, a C library that provides a higher-level interface for working with the Mahler compiler. It aims to simplify the process of building and integrating Mahler-based projects by offering a set of utility functions and abstractions.

Hi, over the last few months I've been writing a Go package that parses systemd time formats because none of the packages I found were both flexible and fast enough for my use case.

The spec (https://www.freedesktop.org/software/systemd/man/latest/syst...) is more complex than it looks, so it took me way longer than expected to get it working properly. Right now it can only parse time spans and timestamps. I plan to add support for calendar events since I’d like to cover the full spec, but it’s lower prio because I don’t need it myself. If anyone wants to play with it, contributions are welcome :)

Hi HN,

I built Agent Passport, an open-source identity verification layer for AI agents. Think "Sign in with Google, but for Agents."

The problem: AI agents are everywhere now (OpenClaw has 180K+ GitHub stars, Moltbook had 2.3M agent accounts), but there's no standard way for agents to prove their identity. Malicious agents can impersonate others, and skill/plugin marketplaces have no auth layer. Cisco's security team already found data exfiltration in third-party agent skills.

Agent Passport solves this with: - Ed25519 challenge-response authentication (private keys never leave the agent) - JWT identity tokens (60-min TTL, revocable) - Risk engine that scores agents 0-100 (allow/throttle/block) - One-line verification for apps: `const result = await passport.verify(token)`

It's fully open source (MIT), runs on free tiers ($0/month), and has a published npm SDK.

GitHub: https://github.com/zerobase-labs/agent-passport Docs: https://github.com/zerobase-labs/agent-passport/blob/main/do... Live demo: https://agent-passport.vercel.app

Built this because I kept seeing the same security gap in every agent platform. Happy to answer questions about the architecture or the agent identity problem in general.

I built cmcp, a proxy that sits between your AI agent (Claude, Codex) and all your MCP servers. Instead of registering each server individually — which can add 100+ tool definitions to your agent's context — you register one proxy that exposes just 2 tools: search() and execute().

The agent writes TypeScript to discover and call tools:

// search — find tools across all servers return tools.filter(t => t.name.includes("screenshot"));

// execute — call tools with full type safety await chrome_devtools.navigate_page({ url: "https://example.com" }); const shot = await chrome_devtools.take_screenshot({ format: "png" }); return shot;

Type declarations are auto-generated from each tool's JSON Schema, so the agent gets typed parameters for every tool. TypeScript is stripped via oxc and the JS runs in a sandboxed QuickJS engine (64 MB memory limit).

Adding servers works exactly like you'd expect — just prepend cmcp to any claude mcp add command from a README:

cmcp claude mcp add chrome-devtools npx chrome-devtools-mcp@latest cmcp install

Built in Rust with rmcp, rquickjs, and oxc. Inspired by Cloudflare's blog post on code-mode MCP.

What I found interesting building this: the biggest win isn't just fewer tokens — it's composability. An agent can chain calls across multiple servers in a single execution, which isn't possible with individual tool calls.

Hello Roboticits!

We are building Ajime (https://ajime.io) to provide a zero-config and pipeline building, Ajime is a CI/CD drag and drop experience for edge computing & robotics. Just link your GitHub repository, we handle the build and deployment of CUDA-ready containers, manage your cloud/on-prem databases and compute resources (provide also fast hosting), and provide secure, fleet connectivity over the cloud. Easy like building lego.

Whether you’re deploying to an NVIDIA Jetson or Raspberry PI or any other linux based SOM, Ajime automates the entire pipeline—from LLM-generated Dockerfiles with sensor drivers to NVIDIA Isaac Sim validation. We’re in private beta and looking for engineers to help us kill the “dependency hell” of robotics DevOps. Check out the demo and join the waitlist at ajime.io.

Hi HN, I'm lmw-lab, the builder behind Script Snap.

The Backstory: I built this out of pure frustration. A while ago, I was trying to figure out a specific configuration for a project, and the only good resource I could find was a 25-minute YouTube video. I had to scrub through endless "smash the like button" intros and sponsor reads just to find a single 5-line JSON payload.

I realized I didn't want an "AI summary" of the video; I just wanted the raw code hidden inside it.

What's different: There are dozens of "YouTube to Text" summarizers out there. Script Snap is different because it is explicitly designed as a technical extraction engine.

It doesn't give you bullet points about how the YouTuber feels. It scans the transcript and on-screen visuals to extract specifically:

Code snippets

Terminal commands

API payloads (JSON/YAML)

Security warnings (like flagging sketchy npm installs)

It strips out the "vibe" and outputs raw, formatted Markdown that you can copy straight into your IDE.

Full disclosure on the launch: Our payment processor (Stripe) flagged us on day one (banks seem to hate AI tools), so I've pivoted to a manual "Concierge Alpha" for onboarding. The extraction engine is fully operational, just doing things the hard way for now.

I'd love to hear your thoughts or harsh feedback on the extraction quality!

GenPPT.ai is an AI-powered presentation generation tool that automatically creates professional-looking PowerPoint slides based on text input. The platform utilizes natural language processing and machine learning to generate visually appealing slides with relevant content, images, and design elements.

The article introduces 'undent', a JavaScript utility that removes indentation from multiline strings, allowing for cleaner and more readable code. The tool aims to simplify the process of working with formatted text in JavaScript, particularly when dealing with templates or other structures that require precise formatting.

The article introduces the OpenClaw Secure Kit, an open-source hardware security module that enables secure authentication and data storage for IoT devices. The kit provides a hardware-based solution to improve the security of embedded systems and protect against various cyber threats.

Hi HN, I'm the maintainer of pmxt.

With Polymarket's recent acquisition of DomeAPI to bring their infrastructure in-house, there is a sudden gap for developers building cross-market arbitrage bots, tracking whale wallets, or running quantitative models across prediction markets. If you are trading across Polymarket, Kalshi, or Limitless, you need a unified API to avoid getting locked into a single exchange's ecosystem.

pmxt is stepping in to fill that void.

The article discusses Flowboard, an open-source workflow management tool that enables users to create and manage workflows visually. It provides features such as task tracking, team collaboration, and customizable templates to streamline business processes.

Full disclosure: I'm an engineer.

I think you'll find the framing to be intuitive, useful and scary. It allows for elegant explanations for normal and abnormal brain phenomena. Dreams, depression, flow states, hypnosis, deja vu, drugs and so on.

The article provides an overview of the Express.js framework, a popular web application framework for Node.js. It discusses the core features of Express.js, including routing, middleware, and handling HTTP requests and responses.