Show stories

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.

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.

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 :)

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.

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.

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.

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.

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 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

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!

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.

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 describes OpenClaw, an open-source browser relay that allows users to access the internet securely and privately through a decentralized network. It provides an overview of the project's features, including encrypted communications, IP obfuscation, and peer-to-peer connectivity.

Zimbabwe has 90+ towns and cities, a population of 15+ million, significant agricultural and mining sectors — and almost no weather infrastructure built specifically for it. Global apps cover Harare and Bulawayo at best, and the AI summaries they generate read like they were written for someone in London. I built mukoko weather to fix this. A few things that shaped the approach: Weather as a public good. The platform is free, no ads, no paywalls. If a smallholder farmer in Chinhoyi needs frost risk data to protect their crops tonight, that can’t be behind a subscription. Hyperlocal context matters more than raw data. Zimbabwe has distinct agricultural seasons — Zhizha (rainy), Chirimo (spring), Masika (early rains), Munakamwe (winter). Elevation varies dramatically: the Highveld sits above 1,200m, the Zambezi Valley below 500m. The AI assistant, Shamwari Weather, is prompted with this geographic and seasonal context so its advice is actually meaningful to the user. Constrained environments are the primary target, not an edge case. Mobile-first, bandwidth-efficient, PWA-installable. The majority of users are on Android, often on 3G or spotty LTE. That’s not a future concern — it’s the baseline. Technical decisions: ∙ Next.js 15 App Router on Cloudflare Pages + Workers ∙ AI summaries via Anthropic Claude SDK, server-side only, cached at the edge with KV and immutable TTL tiers (AI-generated weather advice shouldn’t change retroactively) ∙ Open-Meteo for forecast data (free, high-quality global model coverage) ∙ 90+ Zimbabwe locations validated against geographic bounds with elevation data for frost modelling The broader vision is weather as infrastructure within a larger Africa super app (Mukoko Africa), with Zimbabwe as the proof of concept before expanding to other developing country markets using the same locally-grounded approach. Would love feedback on the approach, especially from anyone who’s built for similar markets — low-bandwidth, mobile-dominant, regions underserved by global platforms.

NF-1 is a new programming language that aims to provide a more efficient and user-friendly alternative to existing languages. It incorporates features such as simplified syntax, improved performance, and enhanced readability to cater to both novice and experienced developers.

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 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.

The article discusses the development of a Chrome extension called Claude, which allows users to interact with the Anthropic language model Claude in a parallel chat interface within their web browser. The extension provides a convenient way for users to access and utilize the advanced natural language capabilities of the Claude model.

Equivalent of "git reset --soft HEAD~1". Got sick of googling it every time with my goldfish memory.

Just a brew package at this point, but feel free to suggest alternatives.

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.

I built Velo because I wanted Superhuman's speed and keyboard workflow without the $30/month price tag or sending all my data through someone else's servers.

Velo is a local-first desktop email client. Your emails live in a local SQLite database - no middleman servers, no cloud sync. It works offline and your data stays on your machine.

What makes it different:

- Keyboard-driven - Superhuman-style shortcuts (j/k navigate, e archive, c compose, /search). You can fly through your inbox without touching the mouse - Built with Tauri v2 + Rust backend - ~15MB binary, low memory usage, instant startup. Not another Electron app - Multi-account - Gmail (API) and IMAP/SMTP (Outlook, Yahoo, iCloud, Fastmail, etc.) - AI features (optional) - Thread summaries, smart replies, natural language inbox search. Bring your own API key (Claude, GPT, or Gemini). Results cached locally - Privacy-first - Remote images blocked by default, phishing link detection, SPF/DKIM/DMARC badges, sandboxed HTML rendering, AES-256-GCM encrypted token storage - Split inbox, snooze, scheduled send, filters, templates, newsletter bundling, quick steps, follow-up reminders, calendar sync

Tech stack: Tauri v2, React 19, TypeScript, SQLite + FTS5 (full-text search), Zustand, TipTap editor. 130 test files.

Available on Windows, macOS, and Linux. Apache-2.0 licensed.

GitHub: https://github.com/avihaymenahem/velo Site: https://velomail.app

I'm a solo developer and would love feedback, especially on UX, features you'd want, or if you run into issues. Happy to answer any questions about the architecture or Tauri v2 in general.

Hi!

I've been frustrated with the fact that the beautiful NumberFlow library for web (link) is not available on React Native - a platform that I think is much more animation native than the web is. And there are no alternatives of the same quality available. So I reimplemented it myself, basically from the ground up.

Introducing Number Flow React Native.

I am aiming for this to be the best number animation library for React Native.

- Beautiful animation easing directly inspired by web NumberFlow - Supporting both Native and Skia versions - Full i18n support for locales, things like compact or scientific notations, etc. - TimeFlow component for timers and counters - Custom digit bounding for things like binary - Supporting 37 different numeral systems such as Arabic, Thai, and many others - A dedicated, shared worklet mode for as much FPS as possible perfect for sliders or gestures for example - Built on top of React Native Reanimated v3+ - Also supports web via Expo Web

Please check out the docs: https://number-flow-react-native.awingender.com/docs And star it on GitHub if you like it: https://github.com/Rednegniw/number-flow-react-native

Let me know what you think!

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.

For a fun side weekend project we gave our own OpenClaw agent called "Mahmut" a face and had a live interview with it. It went surprisingly well.

Here's a sneak peek from the interview: https://x.com/ptservlor/status/2024597444890128767

User speaks, Deepgram transcribes it, OpenClaw Gateway routes it to your agent, ElevenLabs turns the response into speech, and LemonSlice generates a lip synced avatar from the audio. Everything streams over LiveKit in real time.

Latency is about 1 to 2 seconds end to end depending on the LLM. The lip sync from LemonSlice honestly surprised us, it works way better than we expected.

The skill repo has a complete Python example, env setup, troubleshooting guide, and a Next.js frontend guide if you want to build your own web UI for it.

I built this to solve a recurring problem in multi-repo, multi-environment setups: it’s surprisingly hard to answer “what is actually running where?” without checking several systems. WatchTurm is an open-source release visibility layer. It aggregates metadata from sources like GitHub, Jira and CI (e.g. TeamCity), generates a structured snapshot of environment state, and surfaces it in a single control view.

It doesn’t replace CI/CD or manage deployments. It sits above automation and focuses purely on visibility: - what version runs in each environment - how environments differ - what changed between releases

I’m currently using it in my own daily work and would really appreciate technical feedback, especially from teams with multi-environment pipelines.

repo: https://github.com/WatchTurm/WatchTurm-control-room

Hey HN, just wanted to share a fun, vibe-coded Friday night experiment: a little playground for writing cellular automata in a subset of Rust, which is then compiled into WGSL.

Since it lets you dynamically change parameters while the simulation is running via a TUI, it's easy to discover weird behaviors without remembering how you got there. If you press "s", it will save the complete history to a JSON file (a timeline of the parameters that were changed at given ticks), so you can replay it and regenerate the discovery.

You can pan/zoom, and while the main simulation window is in focus, the arrow keys can be used to update parameters (which are shown in the TUI).

Claude deserves all the credit and criticism for any technical elements of this project (beyond rough guidelines). I've just always wanted something like this, and it's a lot of fun to play with. Who needs video games these days.

Hi HN,

I got frustrated with the current landscape of 10-minute mail services. They are often full of ads, Google Analytics trackers, and clunky interfaces—completely defeating the purpose of a "privacy" tool.

I built MephistoMail as a clean, RAM-only frontend alternative. It uses the mail.tm/mail.gw APIs under the hood for actual inbox mapping but handles everything on the client side in volatile memory. If you close the tab, the session is gone. Zero logs are kept on our end.

Tech stack: React 18, Vite, Tailwind CSS, Lucide.

Would love to hear your thoughts, roasts, and suggestions!

Demo: https://mephistomail.site Repo: https://github.com/jokallame350-lang/temp-mailmephisto