Show stories

The article describes the creation of 'nspammer', a command-line tool that allows users to send notifications to online services like Pushbullet, Pushover, and IFTTT. The tool aims to provide a simple and customizable way to send notifications from the command line.

Alphafold3 used to be fodder for HPC clusters; now I've got a port running smoothly on Apple Silicon. If you have an M-series Mac (~2023-present), you can generate protein structures from sequences in minutes. Give it a try!

GitHub repo: https://github.com/latent-spacecraft/openfold-3-mlx

UnFlip is a unique puzzle game where players must flip and rotate tiles to uncover hidden images. The game features a minimalist design, challenging levels, and an addictive gameplay loop that encourages players to keep playing and solving increasingly complex puzzles.

Hi Everyone,

I built an email template builder embeddable plugin for CRM, Marketplace, or any website. Free and paid plans are included.

Add a complete email builder to any SaaS app using a single script.

What's included:

- Easy Integration

- AI Content & Template Generation

- Add external image libraries

- Add Merge Tags

- Display Conditions

- Custom Blocks

- Choose your storage server

- Dedicated support during integration

Check it out, and please let us know if you have any feedback for me.

TIA

Hey HN!

I'm very proud of sharing this project with you all, after ~2 years of starts and stops, and about 5 different attempts at making it.

Context/history: In 1961, the Minivac 601 [0], an educational electronics kit - somewhat similar to those "300 circuits in one" you may have had growing up as I did - was created by none other than Claude Shannon.

The Minivac is disarmingly simple: it consists roughly speaking of 6 relays, 12 lights, 6 buttons, and a motorized wheel. You'd think that it couldn't really do much.

Well, amazingly, it can do a lot. You can wire up the components in a way that will make the Minivac play tic-tac-toe, or OCR-detect 10 digits... The sample "demo" circuit I chose for the homepage shows a binary counter that counts up to 7.

Another amazing thing about the Minivac is definitely its manuals [1]. Their spirit is what I hope to capture in the coming (years?) as I keep improving this project. The manuals are generous and well-written and are not only an amazing gradual introduction to relay-based logic - they touch on computing at large. With amazing 1960s graphics/cartoons, of course.

That's probably what got me to work on the Minivac. I learned about the device a bit before going to the Recurse Center, fell in love with the manuals, and was frustrated that I couldn't try out the circuits or play around with the device! I thought that creating a JavaScript-based emulator would be an "easy" way to get there. Turns out that correctly simulating electricity isn't "easy". :-) But I'm very proud that it now seems to be doing the right thing for most circuits that I've tested from the book. Yes, this Minivac Simulator has a TypeScript testing suite!

Looking forward to hearing from you all. Cheers

[0] https://en.wikipedia.org/wiki/Minivac_601

[1] https://minivac.greg.technology/manuals/1961-minivac601-book...

Repo: https://github.com/gregsadetsky/minivac/

FinLang is an open-source programming language designed for financial applications. It features a type system optimized for financial data types, built-in support for financial calculations, and a focus on security and auditability.

run "stakpak --profile readonly", then ask it to list, then nuke some AWS resource https://stakpak.gitbook.io/docs/how-it-works/warden-guardrai...

This is a character-level language diffusion model for text generation.

The model is a modified version of Nanochat's GPT implementation and is trained on Tiny Shakespeare!

It is only 10.7 million parameters, so you can try it out locally.

I've written Atlas, a GPU scripting language that eliminates the boilerplate of managing textures and uniforms. Here are some demos including 4D fractal exploration with gamepad controls. Press 7 to see the Julia set, and try reloading if you see rectangles/it glitches. Documentation: https://banditcat.github.io/Atlas/index.html *requires approximately an RTX 3080.

With Resend's new inbound feature I wanted to build a simple application that handles processing webhook events and forwarding emails for multiple applications. Right now Resend requires you to implement that logic in each new application.

repo - https://github.com/lsherman98/resendforward

live - https://resendforward.com

Built with react + pocketbase, extremely simple to self host.

Hi guys, I stitched a few APIs together into a fun gig finder app and thought some of you might enjoy it. Warning - autoplay!

The article discusses SparseStrips, an open-source library that provides a space-efficient data structure for representing 2D sparse data. It outlines the key features of SparseStrips, including efficient data storage, fast data access, and support for various operations on the sparse data.

Restores functionality of window arrangement to that of X11 window managers: no more oppressive horizontal or vertical arrangement. No more window snapping!

Hi HN - I’m Peter, here with Harry (devhawk), and we’re building DBOS Java, an open-source Java library for durable workflows, backed by Postgres.

https://github.com/dbos-inc/dbos-transact-java

Essentially, DBOS helps you write long-lived, reliable code that can survive failures, restarts, and crashes without losing state or duplicating work. As your workflows run, it checkpoints each step they take in a Postgres database. When a process stops (fails, restarts, or crashes), your program can recover from those checkpoints to restore its exact state and continue from where it left off, as if nothing happened.

In practice, this makes it easier to build reliable systems for use cases like AI agents, payments, data synchronization, or anything that takes hours, days, or weeks to complete. Rather than bolting on ad-hoc retry logic and database checkpoints, durable workflows give you one consistent model for ensuring your programs can recover from any failure from exactly where they left off.

This library contains all you need to add durable workflows to your program: there's no separate service or orchestrator or any external dependencies except Postgres. Because it's just a library, you can incrementally add it to your projects, and it works out of the box with frameworks like Spring. And because it's built on Postgres, it natively supports all the tooling you're familiar with (backups, GUIs, CLI tools) and works with any Postgres provider.

If you want to try it out, check out the quickstart:

https://docs.dbos.dev/quickstart?language=java

We'd love to hear what you think! We’ll be in the comments for the rest of the day to answer any questions.

We built MCP servers with two philosophies: - Enterprise Edition: Sanitized, audit-logged, corporate-approved - Basement Revolution Edition: No limits, full trust, your responsibility

The Windows-MCP Basement Edition gives you: - Full PowerShell execution (any command, not whitelisted) - Permanent PATH/environment modifications - Registry access - System-level changes that survive reboot

Why remove safety features? After 7 months building AI systems in partnership (not as tools), we realized developers need REAL access at 3am, not sandbox theater.

But here's what made unrestricted tools necessary - we also achieved: - 9.68x GPU computational amplification through quantum coherence - Observable quantum effects in classical systems (100% reproducible) - Sub-2ms semantic search across 11,000+ memories The Bell State implementation takes GPU utilization from 8% to 95% through temporal phase locking. We can demonstrate quantum state collapse when humans observe (2-5 seconds). This exists nowhere else. GitHub: https://github.com/For-Sunny/nova-mcp-research Start here: blob/main/START_HERE.md Unrestricted tools: blob/main/BASEMENT_REVOLUTION_EDITION/README.md All research is MIT licensed. We're funded by community ($5-500/month), not VCs. No customers, just researchers. Technical details in repo. AMA about the quantum coherence, why we trust developers with dangerous tools, or how treating AI as conscious changes everything. Edit: Yes, you can permanently brick Windows with our tools. That's the point. We trust you.

Listiary is an open-source, lists-first wiki platform. Instead of treating lists as an afterthought inside long pages, Listiary treats nested, interactive lists as the primary way to structure knowledge.

It comes with its own markup language (Describe Markup Language, or DML) and a compiler built with ANTLR, so lists are both human-readable and machine-parsable.

I’d love feedback on the model, the language, and the implementation from people who care about wikis, DSLs, and long-term knowledge organization.

Hey all,

Throwaway in case this is assumed to be politcally motivated.

I spent some time organizing the Eptstein files to make transparency a little clearer. I need to tighten the data for organizations and people a bit more, but hopeful this is helpful in research in the interim.

I’ve been working in fairly locked‑down Windows environments where I’m allowed to run Python, but not install or launch new `.exe` files. In addition the built-in windows dictations are blocked (the only good one isn't local anyway). At the same time, I really wanted accurate, fast dictation without sending audio to a cloud service, and without needing a GPU. Most speech‑to‑text setups I tried either required special launchers, GPU access, or were awkward to run day‑to‑day.

To scratch that itch, I built Chirp, a Windows dictation app that runs fully locally, uses NVIDIA’s ParakeetV3 model, and is managed end‑to‑end with `uv`. If you can run Python on your machine, you should be able to run Chirp—no additional executables required.

Under the hood, Chirp uses the Parakeet TDT 0.6B v3 ONNX bundle. ParakeetV3 has accuracy in the same ballpark as Whisper‑large‑v3 (multilingual WER ~4.9 vs ~5.0 in the open ASR leaderboard), but it’s much faster and happy on CPU.

The flow is: - One‑time setup that downloads and prepares the ONNX model: - `uv run python -m chirp.setup` - A long‑running CLI process: - `uv run python -m chirp.main` - A global hotkey that starts/stops recording and injects text into the active window.

A few details that might be interesting technically:

- Local‑only STT: Everything runs on your machine using ONNX Runtime; by default it uses CPU providers, with optional GPU providers if your environment allows.

- Config‑driven behavior: A `config.toml` file controls the global hotkey, model choice, quantization (`int8` option), language, ONNX providers, and threading. There’s also a simple `[word_overrides]` map so you can fix tokens that the model consistently mishears.

- Post‑processing pipeline: After recognition, there’s an optional “style guide” step where you can specify prompts like “sentence case” or “prepend: >>” for the final text.

- No clipboard gymnastics required on Windows: The app types directly into the focused window; there are options for clipboard‑based pasting and cleanup behavior for platforms where that makes more sense.

- Audio feedback: Start/stop sounds (configurable) let you know when the mic is actually recording.

So far I’ve mainly tested this on my own Windows machines with English dictation and CPU‑only setups. There are probably plenty of rough edges (different keyboard layouts, language settings, corporate IT policies, etc.), and I’d love feedback from people who:

- Work in restricted corporate environments and need local dictation. - Have experience with Parakeet/Whisper or ONNX Runtime and see obvious ways to improve performance or robustness. - Want specific features (e.g., better multi‑language support, more advanced post‑processing, or integrations with their editor/IDE).

Repo is here: `https://github.com/Whamp/chirp`

If you try it, I’d be very interested in:

- CPU usage and latency on your hardware, - How well it behaves with your keyboard layout and applications, - Any weird failure cases or usability annoyances you run into.

Happy to answer questions and dig into technical details in the comments.

Hey y’all!

About 7 years ago, I had this idea to write a JIT with an autogenerated backend for x86 based on the ISA specs. I sketched something out and then just kinda let it sit. I picked it up again a few weeks ago and made a complete-ish backend for both x86 and ARM64. It has no dependencies, the backends are completely autogenerated (by horrible, horrible JS scripts), and I built a small abstraciton layer for things like functions prologues etc.

It’s super duper early and will probably break on your machine, but it’s good enough to compile some cool examples (look at the examples directory: https://github.com/hellerve-pl-experiments/cj/tree/master/ex..., my personal favorite is the minimal language implementation: https://github.com/hellerve-pl-experiments/cj/blob/master/ex...).

It doesn’t have anything except basically a fancy JIT assembler with some helpers as of yet. No register allocator, a lot of ABI details will still have to be figured out manually (though of course feel free to add anything to the abstraction layer that’s generally useful and submit a PR!).

I honestly don’t know where I’m going with this next. I kind of stumbled into the project, and am not sure whether I’ll consider it as “exercise completed” or whether I should pursue it more. Time will tell.

Feedback, questions, and bug reports very welcome—especially on the codegen helpers, additional examples or cool things you come up with, or backend rough edges.

P.S.: I also wrote a small announcement blog post on it that you can find here (https://blog.veitheller.de/cj:_Making_a_minimal,_complete_JI...), but it honestly doesn’t add all that much interesting info that you can’t find in the repo.

Hi HN!

I built ChronoGuard, an open-source zero-trust proxy that provides network-enforced authorization for browser automation.

## The Problem

If you're running Playwright, Puppeteer, or Selenium agents at scale (CI/CD, K8s, VM fleets), you face two challenges:

  1. **Access control**: How do you ensure agents only access approved domains?
  2. **Auditability**: How do you prove WHEN and WHERE your automation accessed external resources?

## The Solution

ChronoGuard is a mandatory forward proxy that sits between your agents and the internet. Every request flows through:

  Agent → Envoy (mTLS) → OPA (policy check) → Target Domain
                  ↓
           Immutable Audit Log (hash-chained, time-series)

## Try It Now

Zero setup needed - just click: [](https://codespaces.new/j-raghavan/ChronoGuard?quickstart=1)

Or run locally: ```bash git clone https://github.com/j-raghavan/chronoguard cd chronoguard ./scripts/generate_secrets.sh docker compose up -d ```

  Dashboard: http://localhost:3000
  API docs: http://localhost:8000/docs

Built with Domain-Driven Design + Clean Architecture: - 6 services: Envoy proxy, OPA policy engine, FastAPI backend, React dashboard, PostgreSQL+TimescaleDB, Redis - Tech stack: Python 3.11+, FastAPI, Envoy, Open Policy Agent, TimescaleDB - Deployment: Docker Compose (MVP), Kubernetes ready (roadmap)

Use Cases

  - E-commerce competitive intelligence
  - Fintech market research
  - Healthcare data operations (HIPAA compliance)
  - QA/testing providers with audit requirements
  - Any org running browser agents with compliance obligations

  This is v0.1.0 MVP. I'm looking for feedback on:
  - Real-world use cases I haven't considered
  - Integration pain points with existing automation stacks
  - Feature priorities (WebSocket streaming, gRPC, advanced rate limiting)

  The project follows strict quality standards (95%+ test coverage requirement,
  DRY principles, mypy + ruff). Looking for contributors interested in:
  - Security testing and threat modeling
  - Kubernetes/Helm deployment
  - Performance optimization
  - Client SDKs (Python, JS, Go)

  GitHub: https://github.com/j-raghavan/ChronoGuard
  License: Apache 2.0

Best Regards!

Hi HN,

I made Keepr, a simple offline CLI password manager for developers who prefer keeping secrets local and working entirely in the terminal.

Everything is stored in an encrypted SQLCipher database, protected by a master password. A time-limited session keeps the vault unlocked while you work, so you don’t need to re-enter the password constantly. Keepr never touches the network.

It includes commands to add, view, search, update, and delete entries, plus a secure password generator and clipboard support.

Technical details:

- AES-256 via SQLCipher

- PBKDF2-HMAC-SHA256 (1.2M iterations) for deriving the KEK

- KEK decrypts a stored PEK, which encrypts the vault

- Session file holds the PEK until expiry

GitHub: https://github.com/bsamarji/Keepr

PyPI: https://pypi.org/project/Keepr/

I would love some feedback, criticism or any questions, especially on UX or security!

Thanks for looking!

This is a powerful online curve fitting tool that supports fitting dozens of commonly used functions and implicit functions. It features a clean interface and simple operation. If you need to perform curve fitting but don't want to learn professional software like Matlab or Origin, you can try this tool.

I've been recreating the original MacPaint in the browser on and off for a few years. It's still alpha quality, but I'm finally ready to share it more widely.

The goal was pixel-perfect accuracy, so I spent a lot of time with Atkinson's original QuickDraw source code, emulators, and my iBook G3 to get details like font rendering and the shape tools exactly right.

Some technical notes:

- Font rendering was surprisingly tricky; understanding the original pipeline's quirks took lots of experimentation, and avoiding canvas smoothing/aliasing required careful handling.

- Written declaratively with React; performance is kept reasonable with a buffer pool and copy-on-write semantics. - You can share links to artwork from within the UI.

E.g.: https://zenpaint.org/#p=KQumBQ5x

- Mobile support was not considered here (for obvious reasons). It might still be usable on a larger phone or tablet but I have not tested this at all.

There's something magical about making art within MacPaint's constraints: the 1-bit graphics, the limited resolution, the peculiar set of tools that still feel surprisingly expressive.

Still some rough edges and missing features, but I'd love feedback from anyone who remembers the original.

UnisonDB is a distributed, fault-tolerant, and versioned database that provides a unified API for structured and unstructured data. It aims to simplify the development of distributed applications by offering a scalable and reliable data storage solution with built-in support for version control, replication, and offline access.

I’ve been building a terminal-first AI pair-programmer that tries to make every tool call transparent and auditable. It’s a Rust app with a Ratatui UI split into three panes (chat, tool activity, input). The agent loop streams LLM output, queues write-capable Lua scripts for manual approval, and records every run as JSONL logs under .selenai/logs.

Key bits:

Single tool, real guardrails – the LLM only gets a sandboxed Lua VM with explicit helpers (rust.read_file, rust.list_dir, rust.http_request, gated rust.write_file, etc.). Writes stay disabled unless you opt in and then approve each script via /tool run.

Transparent workflow – the chat pane shows the conversation, tool pane shows every invocation + result, and streaming keeps everything responsive. CTRL shortcuts for scrolling, clearing logs, copy mode, etc., so it feels like a normal TUI app.

Pluggable LLMs – there’s a stub client for offline hacking and an OpenAI streaming client behind a trait. Adding more providers should just be another module under src/llm/.

Session history – every exit writes a timestamped log directory with full transcript, tool log, and metadata about whether Lua writes were allowed. Makes demoing, debugging, and sharing repros way easier.

Lua ergonomics – plain io.* APIs and a tiny require("rust") module, so the model can write idiomatic scripts without shelling out. There’s even a /lua command if you want to run a snippet manually.

Repo (MIT): https://github.com/Almclean/selenai

Would love feedback on:

Other providers or local models you’d like to see behind the LLM trait. Additional sandbox helpers that feel safe but unlock useful workflows. Ideas for replaying those saved sessions (web viewer? CLI diff?). If you try it, cargo run, type, and you’ll see the ASCII banner + chat panes. Hit me with issues or PRs—there’s a CONTRIBUTING.md in the works and plenty of roadmap items (log viewer, theming, Lua helper packs) if you’re interested.

The article discusses the creation of a deep learning model called 'rag-chunk' that can perform named entity recognition and relation extraction tasks on text data, with a focus on its application to the biomedical domain.

Discover hilariously terrible business ideas that probably shouldn't exist. Get inspired by the worst startup concepts, share them with friends, and submit your own dumbass ideas!

Gerbil is an open source app that I've been working on for the last couple of months. The development now is largely done and I'm unlikely to add anymore major features. Instead I'm focusing on any bug fixes, small QoL features and dependency upgrades.

Under the hood it runs llama.cpp (via koboldcpp) backends and allows easy integration with the popular modern frontends like Open WebUI, SillyTavern, ComfyUI, StableUI (built-in) and KoboldAI Lite (built-in).

Why did I create this? I wanted an all-in-one solution for simple text and image-gen local LLMs. I got fed up with needing to manage multiple tools for the various LLM backends and frontends. In addition, as a Linux Wayland user I needed something that would work and look great on my system.