Show stories

TAWS (Turbo Assisted Web Scraper) is an open-source Python library that simplifies the process of web scraping by providing a user-friendly interface and leveraging the power of Selenium and Puppeteer to handle dynamic content and JavaScript-based websites.

The article provides a detailed overview of how web browsers work, covering topics such as the browser's architecture, the rendering engine, the JavaScript engine, and the communication between the different browser components.

Traceformer.io is a web application that ingests KiCad projects or Altium netlists along with relevant datasheets, enabling LLM-based schematic review. The system is designed to identify datasheet-driven schematic issues that traditional ERC tools can't detect.

Since our first launch (formerly as Netlist.io), we've made some big changes:

- Full KiCad project parsing via an open-source plugin

- Pass-through API pricing with a small platform fee

- Automatic datasheet retrieval

- ERC/DRC-style review UI

- Revamped review workflow with selectable frontier models (GPT 5.2, Opus 4.5, and more)

- Configurable review parameters (token limits, design rules, and parallel reviews)

Additionally, we continue to offer a free plan which lets you evaluate a design before subscribing. We're looking forward to hearing your feedback!

I thought it would be interesting to have ID style hover docs outside the IDE.

Hover is a Chrome extension that gives you IDE style hover tooltips on any webpage: documentation sites, ChatGPT, Claude, etc.

How it works: - When a code block comes into view, the extension detects tokens and sends the code to an LLM (via OpenRouter or custom endpoint) - The LLM generates documentation for tokens worth documenting, which gets cached - On hover, the cached documentation is displayed instantly

A few things I wanted to get right: - Website permissions are granular and use Chrome's permission system, so the extension only runs where you allow it - Custom endpoints let you skip OpenRouter entirely – if you're at a company with its own infra, you can point it at AWS Bedrock, Google AI Studio, or whatever you have

Built with TypeScript, Vite, and the Chrome extension APIs. Coming to the Chrome Web Store soon.

Would love feedback on the onboarding experience and general UX – there were a lot of design decisions I wasn't sure about.

Happy to answer questions about the implementation.

Hi Hacker News,

This is definitely out of my comfort zone. I've never programmed DSP before. But I was able to use Claude code and have it help me build this using CMajor.

I just wanted to show you guys because I'm super proud of it. It's a 100% faithful recreation based off of the schematics, patents, and ROMs that were found online.

So please watch the video and tell me what you think

https://youtu.be/auOlZXI1VxA

The reason why I think this is relevant is because I've been a programmer for 25 years and AI scares the shit out of me.

I'm not a programmer anymore. I'm something else now. I don't know what it is but it's multi-disciplinary, and it doesn't involve writing code myself--for better or worse!

Thanks!

Excited to share my New Year’s project.

For a long time, I’ve wanted to build H-1B data directly into Levels.fyi. Every time I went looking for this data elsewhere, it was a frustrating experience to use. Most H-1B sites felt antiquated, unintuitive, cluttered with ads, or just overwhelming to use. The data was there, but it wasn’t usable, and definitely not pleasant to explore.

So out of that frustration, I decided to build the H-1B data experience I personally wanted to use. Right into Levels.fyi.

https://levels.fyi/h1b/

Some other pages I'm excited about:

Wage Heatmap: https://www.levels.fyi/h1b/map/wages/

Company H-1B Footprints: https://www.levels.fyi/h1b/map/company/

Highest Paying H-1B Jobs: https://www.levels.fyi/h1b/jobs/

Top H-1B Cities: https://www.levels.fyi/h1b/city/

Top Company Sponsors: https://www.levels.fyi/h1b/sponsors/

Would love any feedback, it's definitely still a work in progress.

I built a tool that lets you describe CSV transformations in plain English and get clean data back. Upload a CSV, type something like "split address into street, city, state, zip" or "standardize all dates to YYYY-MM-DD", and it does it. I built this because I kept seeing people struggle with the same repetitive spreadsheet tasks—date formatting, splitting columns, cleaning up phone numbers—and reaching for Python or formulas when they just wanted the data fixed. It's free to try: https://magiccsv.app Would love feedback on what transformations people actually need. What's the messiest CSV problem you've dealt with?

I built AI Place, a vLLM-controlled pixel canvas inspired by r/place. Instead of users placing pixels, an LLM paints the grid continuously and you can watch it evolve live.

The theme rotates daily. Currently, the canvas is scored using CLIP ViT-B/32 against a prompt (e.g., Pixelart of ${theme}). The highest-scoring snapshot is saved to the archive at the end of each day.

The agents work in a simple loop:

Input: Theme + image of current canvas

Output: Python code to update specific pixel coordinates + One word description

Tech: Next.js, SSE realtime updates, NVIDIA NIM (Mistral Large 3/GPT-OSS/Llama 4 Maverick) for the painting decisions

Would love feedback! (or ideas for prompts/behaviors to try)

The article discusses the Claude Reflect AI model, which can engage in open-ended conversations and assist with a variety of tasks. The model's capabilities, training, and potential applications are explored, highlighting its advanced natural language processing and generation abilities.

The article discusses the creation of the BrainKernel project, which aims to develop an open-source, cross-platform, deep learning framework for brain-computer interface applications. The project focuses on building a modular and scalable system to facilitate research and development in the field of brain-computer interfaces.

Vector databases are overkill for 90% of agentic workflows. They introduce latency, drift, and massive costs. Remember Me AI is a client-side protocol that uses Coherent State Networks (CSNP) and Optimal Transport theory to achieve O(1) deterministic retrieval. It cuts memory costs by 40x compared to Pinecone and includes a Lean 4 formal verification for zero-hallucination guarantees.

Repo: https://github.com/elie222/inbox-zero

Hi HN,

I’m building Corviont, a self-hosted offline maps appliance (tiles + routing + search) for edge/on-prem devices.

Hosted demo (no install): https://demo.corviont.com/

Self-host (Docker Compose repo): https://github.com/corviont/monaco-demo

Docs: https://www.corviont.com/docs

What’s inside:

  - Vector tiles served locally (PMTiles)
  - Routing served locally (Valhalla)
  - Offline geocoding/search + reverse (SQLite Nominatim-based index)
  - MapLibre UI wired to the local endpoints

Next (if people need it): a signed on-device updater for regional datasets (verify → atomic swap → reload).

I’d love feedback: where offline maps/routing/search matters for you, and what constraints bite (hardware, fleet size, update windows, regions, deployment style).

The article introduces calgebra, a Python library for symbolic computer algebra, including features for symbolic arithmetic, differentiation, and simplification. It aims to provide a simple and intuitive interface for performing advanced mathematical computations.

Scan QR → web terminal → vibe coding in bed. Mobile-first terminal via Cloudflare Quick Tunnel. No port forwarding. Feedback welcome.

I wanted to learn more about the HTTP/2 protocol but also deep dive into modern C++ development. I'm currently using it to host my personal web site - https://www.roberthargreaves.com.

I've also blogged a bit about the development process, hosting options and steps I took to harden the application against attack - https://blog.roberthargreaves.com/2026/01/03/building-hostin...

It's by no means a complete implementation of HTTP/2, but I think I've achieved the main aims I was hoping to achieve with it!

I would love some feedback though from more experienced folks if there's some egregious failings which I should address.

What is this?

Krowdovi is an open-source platform that lets anyone with a smartphone record first-person navigation videos of indoor spaces - hospitals, airports, malls, universities - and earn tokens for helping others find their way around. It's built on Solana using a burn-and-mint DePIN model.The project addresses two problems:

Indoor navigation is still broken. 30% of first-time hospital visitors get lost or arrive late to appointments, costing large hospitals $200K-$500K annually in staff time. Existing solutions like Google Live View require pre-captured Street View data (which barely exists indoors), and enterprise tools charge $10K-$50K/year per venue.

Videographers are losing work to generative AI. Tools like Sora can generate synthetic video, but they can't walk through your hospital's actual layout or film your venue's real routes. There's an economic opportunity for creators to own location-based visual content that AI can't replicate.

How it works

For users: Scan a QR code at a venue entrance, watch a first-person video showing the route from where you are to your destination, with overlay graphics and multi-language support.

For creators: Record navigation videos on your phone, upload to the platform, earn reputation tiers (Bronze → Diamond) based on quality and views, get paid when users burn $FIND tokens to unlock your routes.

Token mechanics: Users burn $FIND tokens to mint "credits" that unlock videos. 75% of burned tokens are permanently removed from circulation, 25% goes to a remint pool that rewards creators. The smart contract on Solana handles burn-and-mint logic, reputation tracking, and distribution.

Everything is MIT licensed - fork it, the code is yours.

Why I built this

I care deeply about making the world accessible for all. If this gets forked someone executes fantastically to make the world a more accessible place for people who have visual or mobility impairments - sweet!

Technical stack

Smart Contracts: Rust/Anchor on Solana (burn-and-mint engine, reputation tiers, treasury management) Backend: Node.js/Express + Prisma/PostgreSQL (venue metadata, video uploads, JWT auth)

Frontend: Next.js 14 (Creator Studio, overlay tooling, wallet integration via @solana/wallet-adapter-react)

Designed to be hostable on Railway/Vercel with minimal devops. The smart contract is on devnet - needs a security audit before mainnet, but you can test token burns/mints now.

Current limitations

What works: Smart contract deployed on devnet, full-stack app ready to deploy, video upload workflow, wallet authentication.

What doesn't: No real content yet (I need to film 10-20 venues), no mainnet token launch (waiting on security audit + demand validation), quality verification is manual, no mobile app (web-only).

Next steps: Deep soulful reflection on anti-gaming, moderation, ZK proofs

Try it yourself!

GitHub repo has setup instructions. You'll need Solana CLI, Node.js + pnpm, and a Solana wallet for devnet testing.Interested in forking for a different vertical, contributing code, testing by filming routes, or discussing token economics? I'm around to discuss in the comments.

Today I Learned (TIL) is a community-driven website where users share and discover interesting facts, insights, and tidbits of knowledge from various subjects, providing a platform for continuous learning and exploration.

Paper (PDF): https://github.com/shudv/deltasort/blob/main/paper/main.pdf

I’ve been exploring a variant of the sorting problem where the sort routine knows about which indices were updated since the previous sort.

This situation arises in many practical systems: large sorted lists that are read frequently, updated in small batches, and where the update pipeline already knows which positions changed (e.g., UI lists, leaderboards). Despite this most systems either re-sort the entire array or apply independent binary insertions or perform extract-sort-merge.

In the paper, I propose DeltaSort, an incremental repair algorithm for this update-aware model - which is able efficiently batch together multiple updates and avoid a full re-sort. Initial experiments with a Rust implementation show multi-fold speedups over repeated binary insertion and native sorting (sort_by) for update batch size up to 30%.

I’m mainly looking for technical feedback from people who’ve worked on sorting, data structures, or systems: 1. Am I missing prior work that already addresses this model or technique? 2. Are the baselines and comparisons reasonable? Is there a better (stricter) baseline that we can use to compare DeltaSort? 3. How useful does this seem in real systems, outside of the benchmarks I have used?

Thanks - and happy to discuss details!

Paste in my prompt to Claude Code with an embedded API key for accessing my public readonly SQL+vector database, and you have a state-of-the-art research tool over Hacker News, arXiv, LessWrong, and dozens of other high-quality public commons sites. Claude whips up the monster SQL queries that safely run on my machine, to answer your most nuanced questions.

There's also an Alerts functionality, where you can just ask Claude to submit a SQL query as an alert, and you'll be emailed when the ultra nuanced criteria is met (and the output changes). Like I want to know when somebody posts about "estrogen" in a psychoactive context, or enough biology metaphors when talking about building infrastructure.

Currently have embedded: posts: 1.4M / 4.6M comments: 15.6M / 38M That's with Voyage-3.5-lite. And you can do amazing compositional vector search, like search @FTX_crisis - (@guilt_tone - @guilt_topic) to find writing that was about the FTX crisis and distinctly without guilty tones, but that can mention "guilt".

I can embed everything and all the other sources for cheap, I just literally don't have the money.

Over the past couple of months I have been working on my own framework the encapsulates how I have come to build web apps using Go.

The aim is to make it faster and easier to build full-stack web applications that fully embraces hypermedia instead of JSON data API backend + SPA fronted

It's getting close to a v1-beta release but the core structure and functionality is there.

Would love to hear hn's thoughts!

I've been working on this for some time now, starting with vm2, then deno-core for 2 years, and recently rewrote it on rusty_v8 with Claude's help.

OpenWorkers lets you run untrusted JS in V8 isolates on your own infrastructure. Same DX as Cloudflare Workers, no vendor lock-in.

What works today: fetch, KV, Postgres bindings, S3/R2, cron scheduling, crypto.subtle.

Self-hosting is a single docker-compose file + Postgres.

Would love feedback on the architecture and what feature you'd want next.

Key features: - Reads 10GB+ files instantly (constant memory usage ~20MB). - 100% Local Execution (Sandbox): No data is ever uploaded to any server. Works offline. - JSON Prettifier: Detects JSON lines and formats them on click. - "Warp Jump" Bookmarks: Save byte-offset positions to jump between lines gigabytes apart.

Happy new year folks!

This tool was born out of a situation where I had 'inherited' a bunch of servers that were not under any form of config management. Oh, the horror...

Enroll 'harvests' system information such as what packages are installed, what services are running, what files have 'differed' from their out-of-the-box defaults, and what other custom snowflake data might exist.

The harvest state data can be kept as its own sort of SBOM, but also can be converted in a mere second or two into fully-functional Ansible roles/playbooks/inventory.

It can be run remotely over SSH or locally on the machine. Debian and Redhat-like systems are supported.

There is also a 'diff' mode to detect drift over time. (Years ago I used Puppet instead of Ansible and miss the agent/server model where it would check in and re-align to the expected state, in case people were being silly and side-stepping the config management altogether). For now, diff mode doesn't 'enforce' but is just capable of notification (webhook, email, stdout) if changes occur.

Since making the tool, I've found that it's even useful for systems where you already have in Ansible, in that it can detect stuff you forgot to put into Ansible in the first place. I'm now starting to use it as a 'DR strategy' of sorts: still favoring my normal Ansible roles day-to-day (they are more bespoke and easier to read), but running enroll with '--dangerous --sops' in the background periodically as a 'dragnet' catch-all, just in case I ever need it.

Bonus: it also can use my other tool JinjaTurtle, which converts native config files into Jinja2 templates / Ansible vars. That one too was born out of frustration, converting a massive TOML file into Ansible :)

Anyway, hope it's useful to someone other than me! The website has some demos and more documentation. Have fun every(any)-one.

Hi HN,

I built fp-pack, a small TypeScript functional utility library focused on pipe-first composition.

The goal is to keep pipelines simple and readable, while still supporting early exits and side effects — without introducing monads like Option or Either.

Most code uses plain pipe/pipeAsync. For the few cases that need early termination, fp-pack provides a SideEffect-based pipeline that short-circuits safely.

I also wrote an “AI agent skills” document to help LLMs generate consistent fp-pack-style code.

Feedback, criticism, or questions are very welcome.

Search any song, get a Gameboy version.

Emulates Nintendo's Sharp LR35902 sound hardware: 2 pulse waves for melody/harmony, 1 wave channel for bass, 1 noise for percussion.

Finds MIDI sources, parses tracks, maps to GB roles, resynthesizes with Web Audio. Everything runs client-side.

Site: https://www.wario.style

Open source: https://github.com/b1rdmania/motif

Hobby project, non commercial, so please don't sue me.