Check out the source code here: https://github.com/IdreesInc/Animal-Crossing-Letter-Generato...
PageIndex takes a different approach to RAG. Instead of relying on vector databases or artificial chunking, it builds a hierarchical tree structure from documents and uses reasoning-based tree search to locate the most relevant sections. This mirrors how humans approach reading: navigating through sections and context rather than matching embeddings.
As a result, the retrieval feels transparent, structured, and explainable. It moves RAG away from approximate "semantic vibes" and toward explicit reasoning about where information lives. That clarity can help teams trust outputs and debug workflows more effectively.
The broader implication is that retrieval doesn't need to scale endlessly in vectors to be powerful. By leaning on document structure and reasoning, it reminds us that efficiency and human-like logic can be just as transformative as raw horsepower.
- One-Click Sharing - Each event gets a unique, memorable URL. Share instantly via any platform or messaging app. - No Hassle, No Sign-Ups - Skip registrations and endless forms. Unlike other event platforms, you create and share instantly — no accounts, no barriers. - Effortless Simplicity - Designed to be instantly clear and easy. No learning curve — just open, create, and go.
It's built into Midday and fully open-source.
Let me know if you have any questions!
Why: Many CVEs happen because TypeScript libraries are vulnerable to Regular Expression Denial of Service attacks. I learned about this problem while doing undergraduate research and found that languages like Rust have built-in protection but languages like JavaScript, TypeScript, and Python do not. This library attempts to mitigate these vulnerabilities for TypeScript and JavaScript.
How: Regolith uses Rust's Regex library under the hood to prevent ReDoS attacks. The Rust Regex library implements a linear-time Regex engine that guarantees linear complexity for execution. A ReDoS attack occurs when a malicious input is provided that causes a normal Regex engine to check for a matching string in too many overlapping configurations. This causes the engine to take an extremely long time to compute the Regex, which could cause latency or downtime for a service. By designing the engine to take at most a linear amount of time, we can prevent these attacks at the library level and have software inherit these safety properties.
I'm really fascinated by making programming languages safer and I would love to hear any feedback on how to improve this project. I'll try to answer all questions posted in the comments.
Thanks! - Jake Roggenbuck
React Web Camera is a lightweight, reusable React component that allows users to capture multiple photos in one camera session, in-browser. It works across standard web apps, responsive UIs, and Progressive Web Apps (PWAs)—unlocking a smoother experience than the default <input type="file" capture> element.
The problem
On mobile (and increasingly on desktops), using: <input type="file" accept="image/*" capture="environment"> only allows taking one picture before the camera closes. Want to add more? You have to reopen it each time.
How React Web Camera solves it
Opens the camera inline in-browser, Lets the user capture multiple photos in one go, Allows previewing captured photos, removing unwanted ones, and submitting everything in a batch, Fully client-side, respects user privacy, Supported across web, responsive UIs, and installable PWAs.
For a while now, our team has been trying to solve a common problem: getting all the context needed to debug a bug report without the endless back-and-forth. It’s hard to fix what you can't see, and console logs, network requests, and other dev data are usually missing from bug reports.
We’ve been working on a new tool called Recording Links. The idea is simple: you send a link to a user or teammate, and when they record their screen to show an issue, the link automatically captures a video of the problem along with all the dev context, like console logs and network requests.
Our goal is to make it so you can get a complete, debuggable bug report in one go. We think this can save a ton of time that's normally spent on follow-up calls and emails.
We’re a small team and would genuinely appreciate your thoughts on this. Is this a problem you face? How would you improve this? Any and all feedback—positive or critical—would be incredibly helpful as we continue to build.
PS - you can try it out from here: https://jam.dev/recording-links
I'm aware that there's like a gazillion e-signing products that exist in this space — including some half decent self-hosted options too. And yes I agree that the success of incumbents such as Docusign come primarily from distribution rather than making a superb product.
But hear me out. Few enterprise tools are as universally disliked as DocuSign: 1,050 Trustpilot reviews, 1.5 stars. To me, that signals two things: (1) a burning problem, and (2) an incumbent that’s barely tolerable.
My "vision" for my current project, Formable, is to eventually create something akin to a Figma/Linear/Canva — late to market, but disruptive through usability and fresh design. One example: our fields aren’t static checkboxes. You can draw any shape/size, then apply logic with natural language (e.g. “must be a valid US state”).
I’m launching the free MVP now, with a waitlist for a much more advanced pro version. I’d love to gather some constructive feedback: what would make you actually love a paperwork tool?
Not the pre-render source (HTML/CSS/JS, templates, bundles) and not a screenshot — but the live, post-render state the browser is actually displaying: - visibility/hidden, disabled/required - current input values and validation/validationMessage - dataset attributes - trimmed text - stable selector paths
Why: LLMs often miss or guess UI state. Screenshots are too opaque, pre-render source is too noisy. A structured snapshot gives reproducible context for debugging forms and flows.
Security: - Runs locally in the browser as a read-only content script. - No telemetry, no external requests. - No page mutation; it only reads the DOM. - Data leaves the browser only if you copy it yourself. - Immune to prompt injection at source level — it never executes or rewrites page code, only serializes visible state.
Use cases: - Debugging client-side forms: capture the real rendered state, not just HTML. - Reproducible bug reports: instead of vague screenshots, share a JSON snapshot of the exact state. - Test automation: snapshot before/after an action to compare behavior. - Prompt engineering: feed structured UI state directly, instead of raw markup or screenshots.
Links: • Chrome Web Store: https://chromewebstore.google.com/detail/element-to-llm/oofd... • Firefox Add-ons: https://addons.mozilla.org/en-US/firefox/addon/element-to-ll...
Curious what people here think about this approach.
The objective is to cement ability to implement core algorithms through repetition. This test suite is not like LeetCode. In fact, it’s more of a prerequisite to LeetCode. The test cases are not exhaustive in the spirit of checking for runtime performance, scalability, etc. Implementations are generalized, so that through practice using this tool, the user can begin avoiding having to think about the algorithmic pattern, and instead focus on its application to the problem at hand.
It uses Minitest to test the user’s implementations, dynamically loaded at runtime.
I trained a diffusion model (Flux Kontext LoRA) on caricature images, 3D-printed a Sharpie mount for my Ender 3, and hacked together a pipeline that goes photo → caricature → G-code. After a lot of trial and error it’s working pretty well, and I put up a little site where you can try it out.
Happy to answer questions or hear any feedback. Thanks!
Now it’s live at https://aimless.chat so you don’t even have to clone or double click anything.
just open and relive your AIM nostalgia.
INSTRUCTIONS:
Host clicks “Create” → gets a blob.
Copy/paste blob to your friend.
Friend pastes, returns blob.
Boom, encrypted chat like it’s middle school and your mom needs the phone line.
Everything is written in ts + nodejs, with great help from Claude Code :) It's still early so feedback & contributions are more than welcome.
I’ve been working on a project called *Testronaut*, an autonomous testing framework that combines AI reasoning with real browser automation. The idea is to let you define end-to-end tests as “missions” in plain English, then have an agent run them through a real browser using Playwright.
Why I built this: I’ve often found end-to-end tests to be fragile, time-consuming to maintain, and difficult to scale. Testronaut tries to reduce the maintenance burden by using AI to adapt tests to small UI changes, while still producing a deterministic report of what passed/failed.
How it works: - Missions can be written as strings or functions. - The agent uses GPT-4o with a set of tools (click, type, navigate, get_dom, etc.) to interact with the page. Support for other LLMs/Models in the works. - Browser control is handled by Playwright. - Reports are generated in both JSON and HTML, with step-by-step breakdowns (including screenshots). - It runs locally via a CLI (`npx testronaut`) and doesn’t require any hosted service. You will need to provide your own OpenAI API key, however.
Current state: - Early days: it works for simple flows and demo apps, but I’m still tuning the reliability and efficiency. - It installs with one command and comes with a sample mission. - Open source on npm/GitHub.
Links: - Docs & quickstart: https://docs.testronaut.app - GitHub: https://github.com/mission-testronaut/testronaut-cli - npm: https://www.npmjs.com/package/testronaut
I’d love feedback from the HN community on: - Where this could be most useful (CI/CD? flaky test replacement? exploratory testing?). - What concerns you’d have about using an AI-driven test runner. - Any “gotchas” I should watch out for in early adoption.
Thanks for taking a look!
Codyssey is a small programming game where you write Python functions to solve minigames. Think pong, flappy bird - the functions serve as a control mechanism for the player.
It evolved from an end-of-year activity I made for an introduction to programming class for 9th graders, difficulty has been adjusted obviously. I ran it as a workshop / competition at several conferences, now considering making it available as a small game.
Some technical details: It runs python in the browser with Brython [0], I originally used Pyodide but it was too heavy for conference WiFis. Code editor is Ace [1].
I'd love to hear your feedback :)
I made a simple web tool called the Minecraft Circle Generator . It helps players create pixel-perfect circles and other shapes in Minecraft by visualizing the block placement.
This started as a side project because I always struggled to get circles right when building in survival mode. The tool lets you choose a radius and block size, then instantly shows the pattern you can copy in-game.
I know there are other generators out there, but I wanted something lightweight, fast, and mobile-friendly. I’d love to hear your feedback, especially on how it could be more useful for builders.
I'm a developer who's been burned by unexpected website downtime one too many times. I tried the big-name monitoring tools but found them overwhelming for my small projects.
So, I built UptimeBuddy – a dead-simple monitoring tool that does one thing well: it checks your site and alerts you (via SMS/Email) the moment it goes down. No complex dashboards, no credit card required for the basic plan.
It's just an MVP right now, but I've put up a landing page to gauge interest.
· Landing Page: https://uptimebuddy-contact.vercel.app/
I'd love your honest feedback:
1. Does the landing page clearly explain what it does? 2. Is this a problem you've faced? 3. Would you use something like this?
Thanks for looking! Any thoughts are hugely appreciated."