Show stories

The linked article is about a guide for hacking the MontyHome home automation system. It provides information on the hardware components, firmware, and vulnerabilities of the system, with the aim of helping hackers and security researchers understand and potentially exploit the system. The guide covers topics such as firmware analysis, network communication, and potential attack vectors, providing a comprehensive overview of the MontyHome system's security landscape.

Hey HN, we're Alexi and Jonas the co-founders of Autotab (https://autotab.com). Autotab is a chrome-based browser you can teach to do complex tasks, with a simple API for running them from your app or backend.

Here is a walkthrough of how it works: https://youtu.be/63co74JHy1k, and you can try it for free at https://autotab.com by downloading the app.

Why a dedicated editor?

The number one blocker we've found in building more flexible, agentic automations is performance quality BY FAR (https://www.langchain.com/stateofaiagents#barriers-and-chall...). For all the talk of cost, latency, and safety, the fact is most people are still just struggling to get agents to work. The keys to solving reliability are better models, yes, but also intent specification. Even humans don't zero-shot these tasks from a prompt. They need to be shown how to perform them, and then refined with question-asking + feedback over time. It is also quite difficult to formulate complete requirements on the spot from memory.

The editor makes it easy to build the specification up as you step through your workflow, while generating successful task trajectories for the model. This is the only way we've been able to get the reliability we need for production use cases.

But why build a browser?

Autotab started as a Chrome extension (with a Show HN post! https://news.ycombinator.com/item?id=37943931). As we iterated with users, we realized that we needed to focus on creating the control surface for intent specification, and that being stuck in a chrome sidepanel wasn't going to work. We also knew that we needed a level of control for the model that we couldn't get without owning the browser. In Autotab, the browser becomes a canvas on which the user and the model are taking turns showing and explaining the task.

Key features:

1. Self-healing automations that don't break when sites change

2. Dedicated authoring tool that builds memory for the model while defining steps for the automation

3. Control flows and deep configurability to keep automations on track, even when navigating complex reasoning tasks

4. Works with any website (no site-specific APIs needed)

5. Runs securely in the cloud or locally

6. Simple REST API + client libraries for Python, Node

We'd love to get any early feedback from the HN community, ideas for where you'd like the product to go, or experiences in this space. We will be in the comments for the next few hours to respond!

Show HN: Cardo - Open Source Desktop Podcast Client

Hi, I'm an amateur developer from Spain. I have released this desktop podcast client that works on Windows, Mac and Linux.

It's a modest project, but it might be useful for you, it has syncing capabilities with Antennapod, Kasts, Repod or other clients. You can manage your subscriptions, queue episodes and even download them to listen to later.

I look forward to hearing your thoughts.

From the post:

Blossom is an open-source robot platform for human-robot interaction (HRI) research that I developed during my PhD. I’ve used Blossom for research in design, machine learning, and telepresence; others have made Blossoms for their own research purposes. I have continued working on “rebuilding” the entire platform: I redesigned the inner frame as a model kit, complete with Gunpla-inspired runners and instructions, and refactored the codebase as r0b0, a Python library for communicating between hardware peripherals and software applications. In preparation to present Blossom at Maker Faire Coney Island, I refined the telepresence interface and enabled conversational interaction with a language model. The new repository is available on GitHub and includes documentation for construction.

This project is inspired by some of the asserts in Unreal engine.

Due to reliance on core_intrinsics it is necessary to develop using nightly Rust, but there are stubs in place so a production build will not require nightly.

I recently released version 0.2 which includes no_std support and adds optional log message arguments to the ensure macro.

The linked article is about setting up an Open Next.js application on Amazon Web Services (AWS). It provides a step-by-step guide on how to deploy a Next.js application on AWS using AWS Amplify, a cloud development service. The article covers the process of creating a new AWS Amplify app, configuring the app's settings, and deploying the Next.js application to the AWS cloud. It also includes information on how to set up environment variables and handle server-side rendering for the deployed application.

The linked article is about a simple command-line tool called "recur" that allows users to execute a command repeatedly at a specified interval. The tool is written in Bash and can be used on Unix-like systems, including Linux and macOS. The article provides instructions on how to install and use "recur", and also includes examples of how to use the tool to monitor system resources, run backups, and more.

Integrate is a fast, small, lightweight Rust library for performing numerical integration of real-valued functions. It is designed to integrate functions, providing a simple and efficient way to approximate definite integrals using various numerical methods.

Integrate supports a variety of numerical integration techniques: - Newton-Cotes methods:

  - Rectangle Rule.
  - Trapezoidal Rule.
  - Simpson's Rule.
  - Newton's 3/8 Rule.

  - Gauss-Legendre.
  - Gauss-Laguerre.
  - Gauss-Hermite.
  - Gauss-Chebyshev First Kind.
  - Gauss-Chebyshev Second Kind.

  - Adaptive Simpson's method

My background is that I have led teams delivering tech projects from startups to enterprise.

Throughout that I have often been asked "Kevin, when do you think this feature/release/update will be done?". Generally it wasn't with a view to locking us into a deadline, but, quite reasonably people wanted to know when to expect it.

Often this was in order to do things like prepare marketing or support in time for the release. Such as when we upgraded an ERP, we needed to prepare the team and customers for a new format of invoice. So very much a real-world need.

Along with that I feel strongly that all such "complex" projects should be agile, I've seen the horrors of old-school waterfall first-hand. Not necessarily big A "Agile" with scrum and such, but certainly agile as in being prepared to track and adjust the plan and expectations at every turn as the learnings, and ideas come in throughout the delivery.

But how do you track to a deadline or expectation, and still be flexible and agile throughout the delivery? Surely there is a tool that can take your remaining plan of work and calculate approximately how you are tracking. Well as it turns out there isn't, so I wrote it and that is "Fixed".

Fixed is focused on answering two crucial questions:

"Are we on track?", and

"What are our options if we're not?"

On that mission I have provided an app with:

- Clear traffic lights and timelines which give an instant view of how the project is tracking

- A visual "what-if" mode for exploring options in scope, resources, and timing - this mode has been designed to be usable as a tool for an individual, or in collaboration with a team such as in a strategic planning meeting

The initial release is a Jira marketplace app. It takes the current plan of work, simulates the delivery of the rest of the tasks and presents projected timing for all your releases, epics and sprints.

It also applies innovative logic to levelling your team by skill. E.g. if you have 20 backend python tasks and 3 backend python devs, it will distribute the tasks evenly across them. Most other systems either don't differentiate your team members, or force you to arbitrarily assign resources to tasks before it levels the plan.

To maintain agility, each day, week, month or whatever, you can push a button and get an update of that projection to have a readout of whether you are on track. Then you can adjust the plan, or expectations, accordingly.

You can see a demo video here: https://youtu.be/CFDbAdexwlY

And add the app for a free trial to your Jira account here: https://marketplace.atlassian.com/apps/1229649?tab=overview&...

More info at: https://fixed.pm

I would love people's views and feedback on how I can make it better serve the vision of reducing the stress of agile project management.

Hey there HN!

I'm Vignesh, and I'm excited to launch Introthem.com — a people search engine that uses facial recognition to provide in-depth, accurate summaries of individuals, assist with HR screening, research prospects, and analyze brands.

The Problem: Researching individuals - whether for hiring or personalizing outreach - is a time-consuming challenge. While RAG-based search engines can help summarize someone's online presence, they have significant limitations. When multiple people share the same name, these engines often mix their information together, creating inaccurate profiles. Even worse, if someone shares a name with a celebrity or public figure, meaningful research becomes nearly impossible as the well-known person's results overshadow everything else.

The Solution: Introthem solves this using facial recognition to accurately classify and organize information by individual. Simply select the specific person you're interested in, and our engine will generate a comprehensive profile.

But that's not all – remember how we typically perform multiple queries to look up someone? For example, if a person founded a company, we then look up how that company is doing. Introthem handles this in-depth research automatically. It generates additional queries based on the first summary the engine produces – what I internally call Content-aware query generation. This helps you conduct thorough research about someone just by their name.

Try it now at https://introthem.com

Would love to hear your feedback, HN!

Demo:

Link 1: https://introthem.com/search?uuid=51d6bc6a-08ad-464e-b4f1-16...

Link 2: https://introthem.com/search?uuid=9f3ad850-1c72-4e8c-ad36-07...

Link 3: https://introthem.com/search?uuid=3f31072e-bf74-4ff2-b1ef-ee...

The linked article is about the Black Hole Vision app, which allows users to visualize the effects of a black hole using augmented reality (AR) technology. The app simulates the distortion of space and time around a black hole, enabling users to observe the bending of light and the gravitational lensing effect. The app is designed to provide an immersive and educational experience for anyone interested in learning about black holes and their remarkable properties.

Hey HN, I last PHP professionally over 15 years ago, and I loved it. I switched to Ruby on Rails, then Node/Go/React/GraphQL as there was a lot more demand for those roles. However, PHP is back!

In true JavaScript fashion, I decided to learn PHP again by building a framework to put all the pieces together in my brain.

I absolutely love Hono.dev, and decided to base the PHP framework on that. Dumbo isn't intended to compete with Laravel, Symphony or Slim, if anything, it's something people can use in production, but also contribute to and be used as a learning resource for others.

Hey there HN! We’re Antonio, Luca, and Yuhang, and we’re excited to introduce Fast GraphRAG, an open-source RAG approach that leverages knowledge graphs and the 25 years old PageRank for better information retrieval and reasoning.

Building a good RAG pipeline these days takes a lot of manual optimizations. Most engineers intuitively start from naive RAG: throw everything in a vector database and hope that semantic search is powerful enough. This can work for use cases where accuracy isn’t too important and hallucinations are tolerable, but it doesn’t work for more difficult queries that involve multi-hop reasoning or more advanced domain understanding. Also, it’s impossible to debug it.

To address these limitations, many engineers find themselves adding extra layers like agent-based preprocessing, custom embeddings, reranking mechanisms, and hybrid search strategies. Much like the early days of machine learning when we manually crafted feature vectors to squeeze out marginal gains, building an effective RAG system often becomes an exercise in crafting engineering “hacks.”

Earlier this year, Microsoft seeded the idea of using Knowledge Graphs for RAG and published GraphRAG - i.e. RAG with Knowledge Graphs. We believe that there is an incredible potential in this idea, but existing implementations are naive in the way they create and explore the graph. That’s why we developed Fast GraphRAG with a new algorithmic approach using good old PageRank.

There are two main challenges when building a reliable RAG system:

(1) Data Noise: Real-world data is often messy. Customer support tickets, chat logs, and other conversational data can include a lot of irrelevant information. If you push noisy data into a vector database, you’re likely to get noisy results.

(2) Domain Specialization: For complex use cases, a RAG system must understand the domain-specific context. This requires creating representations that capture not just the words but the deeper relationships and structures within the data.

Our solution builds on these insights by incorporating knowledge graphs into the RAG pipeline. Knowledge graphs store entities and their relationships, and can help structure data in a way that enables more accurate and context-aware information retrieval. 12 years ago Google announced the knowledge graph we all know about [1]. It was a pioneering move. Now we have LLMs, meaning that people can finally do RAG on their own data with tools that can be as powerful as Google’s original idea.

Before we built this, Antonio was at Amazon, while Luca and Yuhang were finishing their PhDs at Oxford. We had been thinking about this problem for years and we always loved the parallel between pagerank and the human memory [2]. We believe that searching for memories is incredibly similar to searching the web.

Here’s how it works:

- Entity and Relationship Extraction: Fast GraphRAG uses LLMs to extract entities and their relationships from your data and stores them in a graph format [3].

- Query Processing: When you make a query, Fast GraphRAG starts by finding the most relevant entities using vector search, then runs a personalized PageRank algorithm to determine the most important “memories” or pieces of information related to the query [4].

- Incremental Updates: Unlike other graph-based RAG systems, Fast GraphRAG natively supports incremental data insertions. This means you can continuously add new data without reprocessing the entire graph.

- Faster: These design choices make our algorithm faster and more affordable to run than other graph-based RAG systems because we eliminate the need for communities and clustering.

Suppose you’re analyzing a book and want to focus on character interactions, locations, and significant events:

  from fast_graphrag import GraphRAG
  
  DOMAIN = "Analyze this story and identify the characters. Focus on how they interact with each other, the locations they explore, and their relationships."
  
  EXAMPLE_QUERIES = [
      "What is the significance of Christmas Eve in A Christmas Carol?",
      "How does the setting of Victorian London contribute to the story's themes?",
      "Describe the chain of events that leads to Scrooge's transformation.",
      "How does Dickens use the different spirits (Past, Present, and Future) to guide Scrooge?",
      "Why does Dickens choose to divide the story into \"staves\" rather than chapters?"
  ]
  
  ENTITY_TYPES = ["Character", "Animal", "Place", "Object", "Activity", "Event"]
  
  grag = GraphRAG(
      working_dir="./book_example",
      domain=DOMAIN,
      example_queries="\n".join(EXAMPLE_QUERIES),
      entity_types=ENTITY_TYPES
  )
  
  with open("./book.txt") as f:
      grag.insert(f.read())
  
  print(grag.query("Who is Scrooge?").response)

This is the kind of infrastructure that GenAI apps need to handle large-scale real-world data. Our goal is to give you this infrastructure so that you can focus on what’s important: building great apps for your users without having to care about manually engineering a retrieval pipeline. In the managed service, we also have a suite of UI tools for you to explore and debug your knowledge graph.

We have a free hosted solution with up to 100 monthly requests. When you’re ready to grow, we have paid plans that scale with you. And of course you can self host our open-source engine.

Give us a spin today at https://circlemind.co and see our code at https://github.com/circlemind-ai/fast-graphrag

We’d love feedback :)

[1] https://blog.google/products/search/introducing-knowledge-gr...

[2] Griffiths, T. L., Steyvers, M., & Firl, A. (2007). Google and the Mind: Predicting Fluency with PageRank. Psychological Science, 18(12), 1069–1076. http://www.jstor.org/stable/40064705

[3] Similarly to Microsoft’s GraphRAG: https://github.com/microsoft/graphrag

[4] Similarly to OSU’s HippoRAG: https://github.com/OSU-NLP-Group/HippoRAG

https://vhs.charm.sh/vhs-4fCicgsbsc7UX0pemOcsMp.gif

Hey guys, I built a route planner that is mostly focused on bike touring and using existing bike infrastructure.

For each request you're shown what bike tracks/trails your route uses and can further explore them by showing them on map or going to the official trail route.

The main idea for the app is to have a friendly and easy to use planner that would make heavy use of official bike trails data (mainly from OpenStreetMap) and make it easy to plan a longer trip using the best possible bike routes out there.

Currently the app only works for the Euro region but I'm planning to add North America very soon and then rest of the world.

Technical overview: Route finding - Graphhopper sitting in a docker container on a Hetzner server somewhere in Germany. It has 38 GB of graph data(Europe) loaded into RAM for a fast graph traversal.

Web App - Next.js 14 with Typescript, backend on the newest version of .NET

Map tiles - right now I'm using MapTiler their free tier but planning to switch to my own home server soon and host the maps on it.

Hi, we're MathGPT! MathGPT creates Khan-Academy-style animated math videos that intuitively explain complex concepts to students, helping them understand how to solve their problems step-by-step. We're currently serving over 2M users, processing 800M tokens / day and growing! If you try it out, we would appreciate feedback on how we can make the overall experience / video generation better! Email me at ygk2[at]cornell.edu.

pglite-fusion is a PostgreSQL extension that allows you to embed SQLite databases into your PostgreSQL tables by enabling the creation of columns with the `SQLITE` type. This means every row in the table can have an embedded SQLite database.

In addition to the PostgreSQL `SQLITE` type, pglite-fusion provides the `query_sqlite`` function for querying SQLite databases and the `execute_sqlite` function for updating them. Additional functions are listed in the project’s README.

The pglite-fusion extension is written in Rust using the pgrx framework [1].

----

Implementation Details

The PostgreSQL `SQLITE` type is stored as a CBOR-encoded `Vec<u8>`. When a query is made, this `Vec<u8>` is written to a random file in the `/tmp` directory. SQLite then loads the file, performs the query, and returns the result as a table containing a single row with an array of JSON-encoded values.

The `execute_sqlite` function follows a similar process. However, instead of returning query results, it returns the contents of the SQLite file (stored in `/tmp`) as a new `SQLITE` instance.

[1] https://github.com/pgcentralfoundation/pgrx

Hey all! Thought this group might find this interesting - new approach to evaluating RAG pipelines using 'agents as a judge'. We got excited by the findings in this paper (https://arxiv.org/abs/2410.10934), about agents producing evaluations closer to human-evaluators, especially for multi-step workflows.

Our first use case was RAG pipelines, specifically evaluating if your agent MISSED pulling any important chunks from the source document. While many RAG evaluators determine if your model USED its chunk in the output, there's no visibility on if your model grabbed all the right chunks in the first place. We thought we'd test the 'agent as judge', with a new metric called 'potential sources missed', to help evaluate if your agents are missing any important chunks from the source of truth.

Curious what you all think!

I wasn't quite sure if this qualified as "Show HN" given you can't really download it and try it out. However, dang said[0]:

> If it's hardware or something that's not so easy to try out over the internet, find a different way to show how it actually works—a video, for example, or a detailed post with photos.

Hopefully I did that?

Additionally, I've put code and a detailed guide for the netboot computer management setup on GitHub:

https://github.com/kentonv/lanparty

Anyway, if this shouldn't have been Show HN, I apologize!

[0] https://news.ycombinator.com/item?id=22336638

Hi HN!

My name is Nick and this is my fun side project. Please lay it on me. HN can think of Tips.io as a cracked out Tailwind Playground that has page management and amazing AI integration.

There are a few core ideas:

1) The HTML is the CMS

There are no fields or restrictions. Just hover, click, and start tweaking any HTML. Also, certain elements you click will have special easy edit abilities:

- <img> auto creates an uploader, stock photo picker (or HTML)

- <video> auto creates an uploader, stock video picker (or HTML)

- <svg> auto creates a big icon picker (or HTML)

- <div class="prose"> auto creates a WYSIWYG Editor (or HTML)

2) Slices

Think of these as just individual HTML sections of a page or lil baby single-file components. They are self-contained and isolated so you drag them around easily. The real power comes from reuse across your pages and linking them (aka, one HTML footer updates globally). You can also use "slices" from any other tips.io project for quickly expanding your site with more design options.

3) AI Elements, Not Pages

Another cool concept is you can select any element on an HTML slice an edit that individually vs re-streaming/rebuilding and entire component every time. We support 5 different AI models right now. Some other really intense/cool AI integration is coming soon.

4) Tailwind Everything, No Build Step, & Theming

We have a custom "themer" to make creating Tailwind config files near instant with real-time font trying, color palettes/preset trying, and more. All our Tailwind is automatic and requires zero config instantly. The same Tailwind that magic runs client-side will run server-side so quick no one knows a build step is happening. Tailwind and AI are also a match made in heaven.

Other features:

- Animations - Zoomable page tree - Basic Forms (yes on your static site!) - Analytics - Redirects, site passwords, and much more.

Tech:

- 100% Cloudflare Workers - Svelte - UnoCSS

Some resources:

- Promo video: https://www.youtube.com/watch?v=s8U2rJJX-rk - Tutorial & demo video: https://tips.io/tutorial - Just launch: https://new.tips.io

Zyme is an esoteric language for genetic programming: creating computer programs by means of natural selection.

I posted this previously, but there's been a major update.

As a high school student, I love LLMs and the execution of Apple's Appel Intelligence Writing Tools, but was disappointed that nothing like that existed for Windows. I thus created Writing Tools, a better than Apple Intelligence open-source alternative that works system-wide on Windows. It's much better than the tiny 2B parameter Apple Intelligence model!

Features (works system-wide): 1. Select text in a textbox, press the hotkey, and optimise your text in a click (proofread, rewrite, tone changes, custom instructions...). You can also select code to fix/refactor it with the custom instructions. 2. Press the hotkey without selecting any text to bring up a chat UI with the LLM. 3. Select all text on a webpage, press the hotkey, and use the Summarise button to get summary of the webpage/text!

It can use the free Gemini API, or a multitude of local LLMs via Ollama, llama.cpp, KoboldCPP, TabbyAPI, vLLM, etc.

It's completely free & open source, and is heavily privacy-focused (local LLM support, your API key stays on-device, no logging, no tracking, etc.)

GitHub (with a demo video): https://github.com/theJayTea/WritingTools

Writing Tools has also been featured on XDA, Beebom, Windows Central, Neowin, and more! :D

P.S. This is my first major Windows coding project, so I'm especially keen on advice for best practices and potential improvements! Thank you so much for your time :)

We're building a different kind of JavaScript engine, based on data-oriented design and willingness to try something quite out of left field. This is most concretely visible in our major architectural choices:

1. All data allocated on the JavaScript heap is placed into a type-specific vector. Numbers go into the numbers vector, strings into the strings vector, and so on.

2. All heap references are type-discriminated indexes: A heap number is identified by its discriminant value and the index to which it points to in the numbers vector.

3. Objects are also split up into object kind -specific vectors. Ordinary objects go into one vector, Arrays go into another, DataViews into yet another, and so on.

4. Unordinary objects' heap data does not contain ordinary object data but instead they contain an optional index to the ordinary objects vector.

5. Objects are aggressively split into parts to avoid common use-cases having to reading parts that are known to be unused.

If this sounds interesting, I've written a few blog posts on the internals of Nova over in our blog, you can jump into that here: https://trynova.dev/blog/what-is-the-nova-javascript-engine

In the past year, I have built a PST viewer that lets you analyze, visualize, and search multiple PST files.

The project was born from the issues that archivists in France face when dealing with Outlook mailboxes (PST files). In public administration, archivists must collect office data (mostly from Microsoft products) generated during administrative operations. This data will be used by researchers in the future to document and report how public administration works and what the decision-making process was. A lot of information is conveyed through emails, and in most French administrations, they use Outlook. Therefore, archivists must collect and handle PST files but lack proper tools. To work with and analyze PST files, they can only use Outlook, which is slow and cumbersome given the size of the PST files and the limited power of their computers.

My application is called Pesto, and it can be tried for free here: https://pestoviewer.com/.

I wanted to provide the best performance possible for archivists. Pesto is designed to work with PST files of any size (tens of gigabytes) and on low-budget office laptops. To achieve this, I chose Rust for its performance (and also because I wanted to learn and practice Rust). The main challenge was implementing the PST specification in Rust to read and exploit the files effectively.

For the curious, the stack is: Rust, Tauri, Tokio, Serde, TypeScript, React, Vite, and Axum for the website.

I have been in contact with archivists from the main French ministries. There has been some word-of-mouth interest and weak signals, but adoption has been slow, and I can’t make a living from it yet.

So I am looking for an opportunity to work with small, motivated, user-centric teams. If you’re interested, I’d be happy to meet for coffee in Paris.

Have fun with Pesto.

Jean-Baptiste Assouad Creator of Pesto https://jeanbaptisteassouad.com/

Documind is an open-source tool that turns documents into structured data using AI.

What it does:

- Extracts specific data from PDFs based on your custom schema - Returns clean, structured JSON that's ready to use - Works with just a PDF link + your schema definition

Just run npm install documind to get started.

The linked article is about an unofficial Venmo API that allows developers to interact with the Venmo platform without using the official Venmo API. The project, called Venmo-Unofficial-API, is hosted on GitHub and provides a Python-based set of tools and functions for accessing Venmo's features, such as retrieving transaction histories, sending payments, and managing Venmo accounts. The article outlines the project's features, installation instructions, and usage examples, making it a useful resource for developers who want to build applications that integrate with Venmo's services without relying on the official API.