Show stories

Hi everyone, I'm kinda involved in some retrogaming and with some experiments I ran into the following question: "It would be possible to run transformer models bypassing the cpu/ram, connecting the gpu to the nvme?"

This is the result of that question itself and some weekend vibecoding (it has the linked library repository in the readme as well), it seems to work, even on consumer gpus, it should work better on professional ones tho

The article discusses the importance of alphanumeric characters and their use in various applications, including cybersecurity, programming, and data representation.

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

Built a new toy project that lets me remote control Kiro/OpenCode from Slack.

Now I can code from anywhere... even when I should be relaxing

Inspired by various "claw" projects.

Open source on GitHub: DiscreteTom/juan

---

What this does: • Control AI coding assistants through Slack • Write and modify code remotely • Perfect for when you're away from your desk

The article describes the Mcp-server-nucleus, an open-source project that provides a modular and scalable server architecture for building distributed applications. It highlights the project's key features, such as its modular design, plugin-based system, and support for various communication protocols.

The article discusses the creation of 'ghostly' watercolor paintings by Steph Calvert, an artist who uses unconventional techniques to create ethereal, atmospheric images that evoke a sense of mystery and the supernatural.

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.

I built a terminal system monitor that fills a gap I kept hitting when running local LLMs: GPU usage and memory (for both NVidia and AMD) alongside CPU usage and memory, temps, upload, download and OOM kill tracking. All in one view with 50 colour themes.

Consumes less cpu usage than glances (in my testing).

One line install.

I got tired of my AI coding assistant (Claude, Cursor, etc.) losing track of project state across sessions — creating random markdown files, forgetting what was done, repeating work. So I built Saga.

It's an MCP server that gives your AI agent a proper project tracker — Projects > Epics > Tasks > Subtasks — backed by a local SQLite file. One tracker_dashboard call and the agent has full context to resume where it left off.

Key points:

Zero setup — SQLite auto-creates a .tracker.db file per project. No Docker, no Postgres, no API keys. 22 tools — CRUD for the full hierarchy, plus notes (decisions, blockers, meeting notes), cross-entity search, activity log, batch operations. Per-project scoped — Each project gets its own database. Nothing shared, nothing leaked. Activity log — Every mutation is automatically tracked so the agent (or you) can see what changed and when. Install: npx saga-mcp

GitHub: https://github.com/spranab/saga-mcp npm: https://www.npmjs.com/package/saga-mcp

The idea is simple: instead of the LLM trying to remember state in its context window or dumping it into files, give it an actual structured database it can query and update through tool calls. Works with Claude Desktop, Claude Code, Cursor, or any MCP-compatible client.

Would love feedback — especially on the tool design and what's missing.

Open source, massively multiplayer infinite chessboard, with chat and leaderboards.

I'm a data engineer and exploring a data file from the terminal has always felt more painful than it should be for me. My usual flow involved some combination of avro-tools, opening the file in Excel or sheets, writing a quick Python script, using DataFusion CLI, or loading it into a database just to run one query. It works, but it's friction -- and it adds up when you're just trying to understand what's in a file or track down a bug in a pipeline.

A while ago I had this idea of a simple pipe-based CLI tool, like jq but for tabular data, that works across all these formats with a consistent syntax. I refined the idea over time into something I wanted to be genuinely simple and useful -- not a full query engine, just a sharp tool for exploration and debugging. I never got around to building it though. Last week, with AI tools actually being capable now, I finally did :)

I deliberately avoided SQL. For quick terminal work, the pipe-based composable style feels much more natural: you build up the query step by step, left to right, and each piece is obvious in isolation. SQL asks you to hold the whole structure in your head before you start typing.

  `dq 'sales.parquet | filter { amount > 1000 } | group category | reduce total = sum(amount), n = count() | remove grouped | sortd total | head 10'`

It's written in Go -- single self-contained binary, 11MB, no runtime dependencies, installable via Homebrew. I'd love feedback specially from anyone who's felt the same friction.

This is a small side project that kind of escalated: meMCP. It’s a "personal profile protocol," which means it holds data about your professional milestones, education, side projects, and whatever else you feed it. It consists of two parts:

> Backend with scrapers, crawlers, and processors to read data from different sources—primarily LinkedIn for professional history, but also RSS feeds or even Medium (provided you export the raw DOM from your stories overview). Right now, the "connectors" are somewhat limited, as I’ve focused on platforms I actually use. Everything you input is classified into skills, technologies, and general tags. A few metrics are then calculated to score proficiency or the relevance of your capabilities.

> Frontend for your favorite LLM/Agent. It contains everything needed to allow any agent to interact with this MCP. A use case would be generating a CV for job applications, drafting cover letters, or simply showcasing your achievements.

See it in action:

https://mcp.nickyreinert.de/?lang=en

or

https://mcp.nickyreinert.de/human

I know someone built something similar years ago, but I couldn't find it and I am not sure, if this was MCP, too?

Tell me what you think.

Winslop is a free, open-source software tool that provides a graphical interface for managing and optimizing Windows installations, offering features such as task scheduling, backup and restore, and system maintenance.

I got tired of radio apps that make you hunt for working streams. Most directories are full of dead links, duplicates, and placeholder logos - so I built Receiver.

I scan ~50k streams from radio-browser.info, verify each one is actually reachable and streaming, deduplicate, fetch proper logos, and ship the result as a clean SQLite database with the app. What survives: ~30k stations, all working.

Built with Vala and GTK 4 - native GNOME app, no Electron. MPRIS integration, session persistence, 130 language translations. No sign-up, no ads, no tracking.

Available as Snap, .deb, and AppImage. Flathub submission in progress.

Happy to answer questions about the data pipeline, Vala/GTK 4 development, or packaging for Linux.

Hey HN,

I built Nexus because I kept asking why developers share their work on Twitter when GitHub already has everything that matters — contributions, repos, streaks, stack.

Nexus uses GitHub OAuth so your profile is built automatically. No bios to write, no follower games. Features so far: project showcases with repo previews, syntax-highlighted code snippets in the feed, threaded discussions, and a trending algorithm.

Just shipped the social feed (Phase 3). Very early, very few users. Looking for honest feedback from people who actually build things.

What would make you use this over just tweeting about your projects?

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

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 HN, I'm an independent researcher. Over the last several months, I worked alongside a neuro-symbolic AI daemon to formally verify the Clay Millennium Prize "Yang-Mills Mass Gap" problem directly in the Coq theorem prover.

We mapped the finite lattice topology entirely to the ℝ⁴ continuum by reconstructing the 5 Osterwalder-Schrader axioms, isolating the Millennium formulation into exactly 657 sequential Qed proofs.

We aggressively removed every single heuristic Admitted gap from the main topology. The entire framework now rests on exactly 4 standard textbook axioms (e.g., finite-dimensional Perron-Frobenius theorem, standard statistical mechanics).

The repository contains the raw coqc logic. The formally timestamped preprint is on Zenodo (DOI: 10.5281/zenodo.18726858).

I decided to open-source the kernel execution rather than fight arXiv gatekeepers. Happy to answer any questions about theorem proving, the physics, or the AI methodology.

Here's something I realized: the most AI-native knowledge base isn't a SaaS product with an API. It's a folder of markdown files on your disk.

Obsidian stores everything as plain .md files. That means Claude Code (or any AI tool) can grep, read, write, and traverse your entire knowledge base with zero setup. No API keys. No OAuth. No middleware. Just local file I/O.

The only missing piece was sync. I wanted my vault on iPhone (iCloud), on Mac (local), and on GitHub (backup + version history) — without paying $4/mo for Obsidian Sync.

cc-md is ~400 lines of bash. iCloud handles Apple device sync in seconds. A launchd job runs git add/commit/push every 5 minutes. That's it.

One command to install:

bash <(curl -sL https://raw.githubusercontent.com/yuukiLike/cc-md/main/insta...)

The installer auto-discovers your vault, inits git, creates a GitHub repo (if you have gh CLI), and starts syncing. Zero prompts in the best case.

I built this in a weekend, solo, with AI assistance from first line to last. A year ago I couldn't have shipped this. Now I can.

I feel genuinely lucky to be alive in the AI era. It's making childhood dreams come true — one project at a time.

Hi HN, I'm Ethan. I built amux because I was spending more time switching between terminal tabs than actually building things.

amux is an open-source agent multiplexer that lets you run, monitor, and control multiple headless Claude Code sessions from a single dashboard — in your browser, on your phone, or from the terminal.

The problem: I run 5-10 Claude Code agents at a time across different repos. Keeping track of which one is waiting for input, which one is working, and which one broke something was chaos. I needed a control tower.

What it does:

- Spin up any number of Claude Code sessions, each isolated in its own tmux pane

- Live status detection (working / needs input / idle) via SSE — know at a glance which agents need you

- Web dashboard installable as a PWA on your phone. Monitor and send commands from the couch

- Multi-pane grid view to watch multiple agents side by side

- File attachments — paste images, drag-and-drop files directly to agents

- Built-in kanban board for tracking work across all your agents

- Token usage stats so you know what each agent is costing you

- Tailscale integration for secure remote access with zero config

The entire thing is a single Python file with zero dependencies beyond Python 3 and tmux. No build step, no npm install, no Docker. Clone, run `install.sh`, done.

I use this every day to coordinate agents working on different microservices simultaneously. The phone PWA is surprisingly useful — I'll kick off a batch of tasks and check in from my phone while doing other things.

Everything is also exposed via REST API so you can script orchestration workflows with curl.

MIT licensed: https://github.com/mixpeek/amux

Site: https://amux.io

Happy to answer any questions about the architecture or how I use it day to day.

Hi HN - this is a small experiment: what if code had a museum?

I built a Museum of Handwritten Code for foundational constructs and algorithms. I’ve been feeling a strange melancholy watching more and more software generation become automated, and wanted to preserve the "atoms" of programming in a form people can browse, discuss, and (hopefully) learn from.

Yes, it’s a vanity project — but I’m trying to make each exhibit real: code, description, and historical context (with more being added over time).

If AI increasingly writes the software stack (and maybe one day much closer to machine code), then here’s to the for-loops, if-branches, and hash maps that helped build the world we live in. Cheers!

I’d love brutal feedback on whether this feels: * interesting * useful * too gimmicky * or actually a decent teaching / history format

Hey HN,

I got tired of messing with

/etc/hosts and browser SSL warnings every time I started a new project. So I wrote DevBind.

It's a small reverse proxy in Rust. It basically does two things:

1. Runs a tiny DNS server so anything.test just works instantly (no more manual hosts file edits).

2. Sits on port 443 and auto-signs SSL certs on the fly so you get the nice green lock in Chrome/Firefox. It's been built mostly for Linux (it hooks into systemd-resolved), but I've added some experimental bits for Mac/Win too.

Still a work in progress, but I've been using it for my own dev work and it's saved me a ton of time. Would love to know if it breaks for you or if there's a better way to handle the networking bits!

Hi HN, I’m building SEE (Semantic Entropy Encoding): a searchable compression format for JSON/NDJSON. Goal: reduce the “data tax” (storage/egress) and “CPU tax” (decompress/parse) by keeping JSON searchable while compressed, with page-level random access.

I just published a proof-first evaluation release:

Offline DEMO ZIP (~10 min): prints compression ratios + skip rates + lookup latency (p50/p95/p99)

DD pack: audit/repro evidence (decode mismatch=0, extended mismatch=0, audit PASS)

Latest release: https://gitlab.com/kodomonocch1/see_proto/-/releases

Direct DEMO ZIP: https://gitlab.com/api/v4/projects/79686944/packages/generic...

OnePager is included in the release assets.

I’d love feedback on:

what workloads you’d try this on, and

what integration path would make this compelling vs Zstd + external indexing.

Built this because managing multiple AI providers was getting messy. ShuttleAI unifies Claude, GPT and other models behind one subscription API. Would love feedback from devs building agents or production AI workflows.

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