Show stories

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.

Shuru is a lightweight sandbox that spins up Linux VMs on macOS using Apple's Virtualization.framework. Boots in about a second on Apple Silicon, and everything is ephemeral by default. There's a checkpoint system for when you do want to persist state, and sandboxes run without network access unless you explicitly allow it. Single Rust binary, no dependencies. Built it for sandboxing AI agent code execution, but it works well for anything where you need a disposable Linux environment.

Pulled founder info, status, company data, and batch details for 5,700 YC companies. Exported it all as JSON (300k lines) and threw it into an AI model to find patterns.

Wanted to see what YC keeps funding on, what sectors have the highest concentration of active companies, and where the momentum is right now.

Made the dataset exportable so you can run your own analysis.

Curious what patterns others find.

here's the link to a video showcasing the actual data: https://x.com/om_patel5/status/2025058794145829370?s=20

OP here.

    This is a geometric decoding of Chopin's Prelude No. 4.

    I built a 3D music midi visualizer ( https://github.com/jimishol/cholidean-harmony-structure ) and realized that standard music theory couldn't explain the shapes I was seeing. So, I developed the Umbilic-Surface Grammar to map the topology of the harmony.

    This document demonstrates that the prelude's tension isn't random, but a rigorous conflict between 'Gravity' (Station Shifts) and 'Will' (Pivots).

    I am looking for feedback on the logic—specifically from anyone with a background in topology or music theory. Does this geometric proof hold up?

The article describes the Sayou project, an open-source, decentralized platform that aims to revolutionize social media by empowering users with control over their data and interactions. It highlights Sayou's focus on privacy, transparency, and community-driven governance as key features that differentiate it from traditional social media platforms.

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

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.

I’d love to hear your thoughts on the zero-copy approach.

Repo: https://github.com/DumbNoxx/goxe

GridlGame is a free-to-play, multiplayer online word game where players compete to solve Wordle-inspired puzzles against each other in real-time. The game offers a unique social gaming experience with daily challenges, global leaderboards, and the ability to chat with opponents.

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.

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.

Pysaic is a Python library that allows users to create and manipulate ASCII art with ease. The article discusses the key features and capabilities of Pysaic, including the ability to generate random ASCII art and customize existing designs.

The article provides an overview of the TLA+ Workbench, a tool for writing, analyzing, and verifying formal specifications. It covers the key features and benefits of the Workbench, making it a valuable resource for developers and engineers working on complex systems.

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!

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

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

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

The article discusses a new AI-powered tool called AIoChecker that helps developers quickly identify and fix issues in their AI models. It highlights the tool's ability to perform comprehensive checks, provide detailed feedback, and support a wide range of AI frameworks and model types.

Deeper is a deep learning library for Python that provides a simple and intuitive interface for building and training neural networks. It offers a range of advanced features, including support for GPU acceleration and flexible model configurations.

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

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.

The article discusses the Manifold chip architecture, a novel hardware design that aims to improve the efficiency and performance of artificial intelligence and machine learning applications through a modular and scalable approach to processing and memory.

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

The article discusses the spdx2dep tool, which is used to convert SPDX files into a format suitable for dependency management systems. The tool aims to simplify the process of managing software dependencies and licenses by providing a standardized way to represent and exchange software package information.

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 platform where you configure your own technical indicators and get trading signals straight to Telegram — no code required. Looking for feedback: what works, what's missing, what would you add?

The Problem Nobody Talks About You want to accept a $10,000 USDC payment. You have two options:

Option A: Integrate a payment processor like Coinbase Commerce. Set up an account, embed their checkout widget, handle their SDK. Pay $100 in fees (1%).

Option B: Build your own blockchain listener. Learn ethers.js, subscribe to USDC transfer events, handle reorgs, confirmations, edge cases. Two weeks of work, minimum.

There's no middle ground. No service that just tells you: "Yes, this specific payment arrived."

Until now.

https://paywatcher.dev?utm_source=hackernews

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.

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.