Show stories

No signup required—just upload or record a video to verify its truthfulness. You can test it on anyone: internet clips, your significant other, or even yourself.

I know there are tons of scammy 'lie detector' apps out there, but I built this using SOTA multimodal models in hopes of creating a genuine breakthrough in the space. It analyzes micro-expressions, voice patterns, and context. In my own testing (over 50 trials), it reached about 85% accuracy, which honestly felt a bit scary.

It’s also fun to test on famous YouTube clips (like Obama talking about UFOs). I’d love to hear what you think and will be improving Watsn.ai every day based on your feedback!

I've worked at several companies during the past two decades and I kept encountering the same issues with internal technical proposals:

- Authors would change a spec after I started writing code

- It's hard to find what proposals would benefit from my review

- It's hard to find the right person to review my proposals

- It's not always obvious if a proposal has reached consensus (e.g. buried comments)

- I'm not notified if a proposal I approved is now ready to be worked on

And that's just scratching the surface. The most popular solutions (like Notion or Google Drive + Docs) mostly lack semantics. For example it's easy as a human to see a table in a document with rows representing reviewers and a checkbox representing review acceptance but it's hard to formally extract meaning and prevent a document from "being published" when criteria isn't met.

RFC Hub aims to solve these issues by building an easy to use interface around all the metadata associated with technical proposals instead of containing it textually within the document itself.

The project is still under heavy development as I work on it most nights and weekends. The next big feature I'm planning is proposal templates and the ability to refer to documents as something other than RFCs (Request for Comments). E.g. a company might have a UIRFC for GUI work (User Interface RFCs), a DBADR (Database Architecture Decision Record), etc. And while there's a built-in notification system I'm still working on a Slack integration. Auth works by sending tokens via email but of course RFC Hub needs Google auth.

Please let me know what you think!

Hey HN! Over the weekend (leaning heavily on Opus 4.5) I wrote Jargon - an AI-managed zettelkasten that reads articles, papers, and YouTube videos, extracts the key ideas, and automatically links related concepts together.

Demo video: https://youtu.be/W7ejMqZ6EUQ

Repo: https://github.com/schoblaska/jargon

You can paste an article, PDF link, or YouTube video to parse, or ask questions directly and it'll find its own content. Sources get summarized, broken into insight cards, and embedded for semantic search. Similar ideas automatically cluster together. Each insight can spawn research threads - questions that trigger web searches to pull in related content, which flows through the same pipeline.

You can explore the graph of linked ideas directly, or ask questions and it'll RAG over your whole library plus fresh web results.

Jargon uses Rails + Hotwire with Falcon for async processing, pgvector for embeddings, Exa for neural web search, crawl4ai as a fallback scraper, and pdftotext for academic papers.

I woke up Sunday morning ready to schedule my week at NeurIPS. To my immediate horror, the NeurIPS.cc poster sessions have 1k+ posters in a stupid little dropdown. So I built a little app to help navigate them by research area/keywords/etc. Built it in a few hours with codex, gemini-cli, and Claude code. Same stack that produced 50% of the papers at NeurIPS ;)

Free to use, no signup.

Finally, after landing component preview support and moving the codebase under the RazorConsole org, we think it’s the right time to introduce RazorConsole to Hacker News.

# RazorConsole

RazorConsole is a library for building interactive terminal applications using Razor components, rendered through Spectre.Console. If you’ve used React Ink, the idea will feel familiar: a declarative component model that stays cleanly separated from your application logic. If you like how Blazor/Razor expresses UI but want to target the terminal, RazorConsole might be a good fit.

# Highlights

- Author terminal UI using familiar Razor/Component syntax

- Render Razor components directly into Spectre.Console renderables

- Keep your UI declarative and composable, similar to Blazor and React Ink

# Links

- GitHub: https://github.com/RazorConsole/RazorConsole

- Website: https://razorconsole.github.io/RazorConsole

A special shout-out to Nick Chapsas, who created an excellent introduction video:https://www.youtube.com/watch?v=1C1gTRm7BB4. His coverage brought a huge boost during RazorConsole’s cold-start phase, and we sincerely appreciate it. If you want a quick, clear overview of what the project does, his video is the perfect starting point.

# What’s next

- More interaction: mouse and scroll-wheel events

- More layouts & styling: additional layout primitives (e.g., flex-like patterns), potential CSS-style syntax

- More components: a component registry experience similar to shadcn

The article provides a comprehensive guide to the engineering practices and tools used in the development of FFmpeg, a popular multimedia framework. It covers topics such as build systems, testing, and continuous integration, offering insights into the project's technical processes.

I built a system that monitors ~200,000 news RSS feeds in near real-time and clusters related articles to show how stories spread across the web.

It uses Snowflake’s Arctic model for embeddings and HNSW for fast similarity search. Each “story cluster” shows who published first, how fast it propagated, and how the narrative evolved as more outlets picked it up.

Would love feedback on the architecture, scaling approach, and any ways to make the clusters more accurate or useful.

Live demo: https://yandori.io/news-flow/

In my area I have 8 ANPR car parks within a 10 min radius that are free to park in, but you need to remember to enter your registration plate if not you are hit with a £70+ fine. This is easy to forget for older people. People who are with the kids. ect ectt. so I have made an app that sends a push notification after you enter one.Its free. I will add pro features in the future to keep it alive and server costs. Im in the process of populating the car parks but users can still add there own in the local area if they want

The new Gemini 3 Pro Image model (aka Nano Banana) is incredible at generating slides, so I thought it would be fun to build a CLI tool that lets you edit PDF presentations using plain English. The tool converts the page you want to edit into an image, sends it to the model API together with your prompt to generate an edited image, then converts the updated image back and stitches into the original document.

Examples:

- `nano-pdf edit deck.pdf 5 "Update the revenue chart to show Q3 at $2.5M"`

- `nano-pdf add deck.pdf 15 "Create an executive summary slide with 5 bullet points"`

Features:

- Edit multiple pages in parallel

- Add entirely new slides that match your deck's style

- Google Search enabled by default so the model can look up current data

- Preserves text layer for copy/paste and search

It can work with any kind of PDF but I expect it would be most useful for a quick edit to a deck or something similar.

GitHub: https://github.com/gavrielc/Nano-PDF

The article describes the Spritefusion Pixel Snapper, a tool that allows users to create and export pixel art from a variety of image sources. The tool offers a range of features, including image cropping, pixel scaling, and color palette customization, aimed at simplifying the pixel art creation process.

I usually look up palettes and the UI comes out nice except some color pairs don't pass wcag color contrast and well - just isn't readable Ended up writing a tiny library that automatically nudges your text color just enough to pass AA or AAA, while keeping it visually similar to the original along with a color contrast linter so we can use it in CI Thought you guys might find it useful too, it's foss :>

ReferralLoop is a referral marketing platform that helps businesses leverage customer referrals to drive growth, offering features like automated referral campaigns, custom referral programs, and analytics to track referral performance.

It's this time of year to discover cool projects bringing back memories of the good old days.

I am still learning ImGUI and this is a master piece in my opinion.

https://github.com/tildearrow/furnace

This article explores the integration of Rust into the XV6 operating system, a research-oriented Unix-like operating system. It discusses the challenges and benefits of using Rust, a systems programming language, to enhance the security and reliability of the XV6 kernel.

LogicART.ai is an artificial intelligence company that specializes in developing advanced language models and other AI technologies. The company focuses on pushing the boundaries of AI capabilities in areas such as natural language processing, computer vision, and decision-making.

The article provides an overview of Wingfoil, a water sports activity that combines elements of windsurfing, kitesurfing, and foiling. It discusses the equipment, technique, and benefits of this emerging sport, which allows users to hydrofoil above the water's surface using a small wing-like structure.

I got DOOM running in KiCad by rendering it with PCB traces and footprints instead of pixels.

Walls are rendered as PCB_TRACK traces, and entities (enemies, items, player) are actual component footprints - SOT-23 for small items, SOIC-8 for decorations, QFP-64 for enemies and the player.

How I did it:

Started by patching DOOM's source code to extract vector data directly from the engine. Instead of trying to render 64,000 pixels (which would be impossibly slow), I grab the geometry DOOM already calculates internally - the drawsegs[] array for walls and vissprites[] for entities.

Added a field to the vissprite_t structure to capture entity types (MT_SHOTGUY, MT_PLAYER, etc.) during R_ProjectSprite(). This lets me map 150+ entity types to appropriate footprint categories.

The DOOM engine sends this vector data over a Unix socket to a Python plugin running in KiCad. The plugin pre-allocates pools of traces and footprints at startup, then just updates their positions each frame instead of creating/destroying objects. Calls pcbnew.Refresh() to update the display.

Runs at 10-25 FPS depending on hardware. The bottleneck is KiCad's refresh, not DOOM or the data transfer.

Also renders to an SDL window (for actual gameplay) and a Python wireframe window (for debugging), so you get three views running simultaneously.

Follow-up: ScopeDoom

After getting the wireframe renderer working, I wanted to push it somewhere more physical. Oscilloscopes in X-Y mode are vector displays - feed X coordinates to one channel, Y to the other. I didn't have a function generator, so I used my MacBook's headphone jack instead.

The sound card is just a dual-channel DAC at 44.1kHz. Wired 3.5mm jack → 1kΩ resistors → scope CH1 (X) and CH2 (Y). Reused the same vector extraction from KiDoom, but the Python script converts coordinates to ±1V range and streams them as audio samples.

Each wall becomes a wireframe box, the scope traces along each line. With ~7,000 points per frame at 44.1kHz, refresh rate is about 6 Hz - slow enough to be a slideshow, but level geometry is clearly recognizable. A 96kHz audio interface or analog scope would improve it significantly (digital scopes do sample-and-hold instead of continuous beam tracing).

Links:

KiDoom GitHub: https://github.com/MichaelAyles/KiDoom, writeup: https://www.mikeayles.com/#kidoom

ScopeDoom GitHub: https://github.com/MichaelAyles/ScopeDoom, writeup: https://www.mikeayles.com/#scopedoom

Hi! Recently smart-glasses with cameras like the Meta Ray-bans seem to be getting more popular. As does some people's desire to remove/cover up the recording indicator LED. I wanted to see if there's a way to detect when people are recording with these types of glasses, so a little bit ago I started working this project. I've hit a little bit of a wall though so I'm very much open to ideas!

I've written a bunch more on the link (+photos are there), but essentially this uses 2 fingerprinting approaches: - retro-reflectivity of the camera sensor by looking at IR reflections. mixed results here. - wireless traffic (primarily BLE, also looking into BTC and wifi)

For the latter, I'm currently just using an ESP32, and I can consistently detect when the Meta Raybans are 1) pairing, 2) first powered on, 3) (less consistently) when they're taken out of the charging case. When they do detect something, it plays a little jingle next to your ear.

Ideally I want to be able to detect them when they're in use, and not just at boot. I've come across the nRF52840, which seems like it can follow directed BLE traffic beyond the initial broadcast, but from my understanding it would still need to catch the first CONNECT_REQ event regardless. On the bluetooth classic side of things, all the hardware looks really expensive! Any ideas are appreciated. Thanks!

It's quite limited but does the job, I invite anybody not aware of what cram tests are to give them a try, being on Unix with the original cram or Windows with this one ;)

Hi HN,

I just launched Tinyfocus, a small productivity tool designed specifically for solo founders and builders. The goal is simple: help you focus on what matters and get more done in less time.

Here’s what Tinyfocus does:

Lets you track your top tasks and prioritize efficiently.

Provides micro dashboards to keep your daily focus in check.

Lightweight, no distractions, no fluff.

I built it entirely by myself, iterating in public, and I wanted to share it with the community to get feedback.

It’s been crazy seeing how a simple tool can make such a difference in daily focus, especially when you’re juggling multiple projects as a solo founder.

Check it out here: tinyfoc.us

I’d love to hear your thoughts – any feedback, feature ideas, or bugs you notice.

Thanks!

Netlist.io is a platform that connects businesses with verified digital talent, offering services such as web development, digital marketing, and software engineering. The site aims to streamline the hiring process and help companies find skilled freelancers to meet their digital needs.

Flowctl is a self-service platform that gives users secure access to complex workflows, all in a single binary. These workflows could be anything, granting SSH access to an instance, provisioning infra, or custom business process automation. The executor paradigm in flowctl makes it domain-agnostic.

This initial release includes: - SSO with OIDC and RBAC - Execution on remote nodes via SSH (fully agentless) - Approvals - Cron-based scheduling - Flow editor UI - Encrypted credentials and secrets store - Docker and Script executors - Namespaces

I built this because I needed a simple tool to manage my homelab while traveling, something that acts as a UI for scripts. At work, I was also looking for tools to turn repetitive ops/infra tasks into self-service offerings. I tried tools like Backstage and Rundeck, but they were either too complex, or the OSS versions lacked important features.

Flowctl can simply be described as a pipeline (like CI/CD systems) that people can trigger on-demand with custom inputs.

Would love to hear how you might use something like this!

Demo - https://demo.flowctl.net

Homepage - https://flowctl.net

GitHub - https://github.com/cvhariharan/flowctl

Zint is an open-source barcode generator library that supports a wide range of barcode symbologies, including 1D and 2D barcodes. It is designed to be used as a library in other applications and provides a simple API for generating barcodes.

I used to be a lawyer and made some apps' privacy policies. Now, I have developed a software that scans projects and generates a policy.

It has been almost 10 years since I started the opencv-python packaging project. Scaling it to more than 100 million downloads as a side project showed me how much ease of installation and proper package distribution matter to users. It gave the computer vision ecosystem a noticeable boost. Now I have a new idea that I hope can help even more people across the broader software engineering world.

A while ago, I realized I kept giving the same advice to teammates and friends when they ran into a programming issue they couldn't easily solve: go to GitHub and look at how others solved it.

There is a huge pool of underused example material across open source. Most problems developers face are not that novel. With enough digging, someone has already solved the same issue in code or at least posted a workaround to an issue or discussion thread.

The trouble is that GitHub search is limited and works only when you already know the right keywords. You also need the time and patience to go through and read all the results, connect information across files, repositories, issues, discussions, and other metadata, and then turn that into a working solution. The same limitations apply to Stack Overflow and other search tools.

LLMs changed a lot, but they did not change this. They do not perform equally well across all programming languages, and their training data is always stale. They cannot reliably show how to combine multiple libraries in the way real projects do. For these and many other cases, they need a real, canonical code example rather than an outdated piece of documentation written for humans.

That is why I started building GitHits. It is designed to handle the work that humans and AI coding agents struggle with: finding real solutions in real repositories and connecting the dots across the open source ecosystem.

GitHits searches millions of open-source repositories at the code level, finds real code and surrounding metadata that match the intent of your blocker, and distills the patterns it finds into one example.

The initial product is in private beta, with MCP support to connect GitHits to your favorite coding agent IDE or CLI.

What makes it different from Context7 and other generic documentation search tools:

- It is built around unblocking, not general search

- It does not require manual indexing jobs

- It works for humans through the web UI and for agents through the MCP

- It clusters similar samples across repositories so you can see the common path real engineers took

- It ranks the sources using multiple signals for higher quality: the selected sources might be, for example, a combination of code files, issues, and docs

- It generates one token-efficient code example based on real sources

It is not perfect yet. Right now, GitHits supports only Python, JS, TS, C, C++, and Rust. More languages and deeper coverage are coming, and I would appreciate early feedback while the beta is still taking shape. If you have ever lost hours stuck on a blocker you knew someone else had solved already, I would love to hear what you think.

The model uses a 1024-dimensional complex Hilbert space with 32 layers of programmable Mach–Zehnder meshes (Reck architecture) and derives token probabilities directly via the Born rule.

Despite using only unitary operations and no attention mechanism, a 1024×32 model achieves coherent TinyStories generation after < 1.8 hours of training on a single consumer GPU.

This is Part 1 - the next step is physical implementation with $50 of optics from AliExpress.

I built this quiz after realizing how good AI has gotten at mimicking literature, speeches, and images. It's one strike and you're out. It includes AI-generated Shakespeare, fake MLK speeches, photorealistic images, and movie dialogue. I got several of my own questions wrong while building it.

This isn't about testing your English degree, it's more about showing how well AI can now forge canonical cultural references. We've hit a point where the fakes are genuinely convincing. Where AI still slips up: Over-explanation (real Shakespeare is more economical) Generic metaphors vs. specific imagery Too polished (humans are messier)

But these tells are fading fast! Built with React, ~50 questions (for now). The images are tough if you haven't already seen them before. Curious what scores people get.

I wanted to listen to music with friends who live far away. Not "watch a YouTube video together" - actually share what I'm hearing in real-time, like we're in the same room.

Pulse is what came out of that. Anyone can host a live audio stream from their browser tab or system audio. Listeners join, music recognition identifies tracks automatically, and there's chat with 7TV emotes. No account required - you get an anonymous code and you're in.

We're running demo rooms that stream NTS Radio and SomaFM 24/7 (indie project, not affiliated - we backlink to the original stations). There's also a "Money For Nothing 24/7" room if you want to loop that Dire Straits instrumental forever.

Think of it as co-listening infrastructure. Bedroom DJs, listening parties, or just sharing your current vibe.