Show stories

Inspired by the "ffmpeg by examples" comments, here's a simple script that pulls it all together. Set your OpenAI API key env var and make the script executable, and you're golden.

I created a TUI for systemd/systemctl called isd (interactive systemd).

It provides a fuzzy search for units, auto-refreshing previews, smart sudo handling, and a fully customizable, keyboard-focused interface for power users and newcomers alike.

It is a more powerful (but heavier) version of sysz, which was the inspiration for the project.

This should be a huge timesaver for anybody who frequently interacts with or edits systemd units/services. And if not, please let me know why! :)

Me and my friend built an unique content based Recommendation System, where user can just select Anime or write synopsis and our system will find the most similar anime available. We used Qdrant Vector Database for the Recommendations.

Other Features includes, Streaming, Custom watchlist creation and sharing of watchlists. We update our Database regularly and plan to introduce new features in future.

Hi all!

I wanted to integrate electricity price forecasts into my HomeAssistant setup so I could do cool automations like waiting to start the laundry until prices are lower. However, I couldn’t find a good API for forecasting day-ahead electricity prices, so… I built one!

This API forecasts electricity prices for the Netherlands, using AI and machine learning under the hood to provide pretty decent estimates. I plan to keep improving it and expand it to other electricity markets.

With this API, you can: - Predict electricity prices for the Dutch day-ahead market. - Use the forecasts to optimize energy usage in your smart home setup.

This is an MVP, and I’d love to hear your feedback or ideas to make it even better!

API Documentation: https://forge-forecasts.onrender.com/

Looking forward to hearing your thoughts!

The article explores the concept of a float gallery, a unique exhibition space where artworks are displayed on floating platforms in a body of water. It discusses the artistic and logistical challenges of creating such an innovative exhibition format.

The article discusses a new GUI tool for editing Mermaid class diagrams, which allows users to create and modify class diagrams visually without having to write code. The tool provides a user-friendly interface and features like real-time diagram previewing, making it easier for non-technical users to work with Mermaid diagrams.

I built this educational game to help people identify and understand dark patterns in digital products. It features 10 interactive scenarios based on real-world examples.

The game includes:

• Interactive pattern recognition scenarios • Explanations of psychological principles • Simulated real-world examples with guided feedback

Built with Next.js, TypeScript, and Tailwind.

I'd especially appreciate feedback on the educational approach and scenario design.

Scratching my own itch. I had to do this for showing information on ZX Spectrum games. So thought I'd turn it into a useful tool for other people to use.

Hi! I've been working on the flipjump project, a programming language with 1 opcode: flip (invert) a bit, then jump (unconditionally). So a bit-flip followed by more bit-flips. It's effectively a bunch of NOT gates. This language, as poor as it sounds, is RICH.

Today I completed my compiler from C to FlipJump. It takes C files, and compiles them into flipjump. I finished testing it all today, and it works! My key interest in this project is to stretch what we know of computing and to prove that anything can be done even with minimal power.

I appreciate you reading my announcement, and be happy to answer questions.

More links:

- The flipjump language: https://github.com/tomhea/flip-jump https://esolangs.org/wiki/FlipJump

- c2fj python package https://pypi.org/project/c2fj/

Chrome extension that opens ChatGPT, Claude, Perplexity, Google, and DuckDuckGo in new tabs when you type 'm query' in the address bar.

No tracking. Open source. MIT license.

Hi HN, we build an open-source operating system extension for orchestrating robot swarms fully decentralized.

This first beta version allows you to create fully decentralized robot swarms. The system will set up a wireless mesh network and run a p2p networking stack on top of it, such that nodes can interact with each other through various abstractions using our SDKs (Rust, Python, TypeScript) or a CLI.

We hope this is a step toward better inter-robot communication (and a fun project if you have a few Raspberry Pis lying around).

Our mesh network is created by B.A.T.M.A.N.-adv and we’ve combined this with optimized decentralized algorithms. To a user, it becomes very easy to write decentralized applications involving several peers since we’ve abstracted away much of the complexity. Our system currently offers several orchestration primitives (Key-Value Store, Pub-Sub, Discovery, Request-Response, Mesh Inspection, Debug Services, etc.)

Internally, everything except the SDKs is written in Rust, building on top of libp2p. We use gRPC to communicate between the SDKs and the CLI, so libraries for other languages are possible, and we welcome contributions (or feedback).

The C++ SDK and a ROS package that should feel natural to roboticists are in the works. Soon we also want to support a collaborative SLAM and a distributed task queue.

We’d love to hear your thoughts! :)

Nyxelf simplifies static and dynamic analysis of ELF binaries, enabling you to extract valuable insights effortlessly. And can be used for vulnerability assessments, unpacking, syscall tracing, and memory analysis.

I realized that the PDF engines of modern desktop browsers (PDFium and PDF.js) support JavaScript with enough I/O primitives to make a basic game like Tetris.

It was a bit tricky to find a union of features that work in both engines, but in the end it turns out that showing/hiding annotation "fields" works well to make monochrome pixels, and keyboard input can be achieved by typing in a text input box.

All in all it's quite janky but a nice reminder of how general purpose PDF scripting can be. The linked PDF is all ASCII so you can just open it in a text editor, or have a look at the source code here: https://github.com/ThomasRinsma/pdftris/blob/main/gengrid.py

If you're currently caffeinated you may or may not want to hop on to this zap-or-confetti mental math operant conditioning chamber

Sorry for the low effort app slop but this is what you get haha

Certified sound free because that sort of dopamine is just distracting

Hi HN - Peter from DBOS here with my co-founder Qian (qianl_cs)

Today we want to share our TypeScript library for lightweight durable execution. We’ve been working on it since last year and recently released v2.0 with a ton of new features and major API overhaul.

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

Durable execution means persisting the execution state of your program while it runs, so if it is ever interrupted or crashes, it automatically resumes from where it left off.

Durable execution is useful for a lot of things:

- Orchestrating long-running or business-critical workflows so they seamlessly recover from any failure.

- Running reliable background jobs with no timeouts.

- Processing incoming events (e.g. from Kafka) exactly once

- Running a fault-tolerant distributed task queue

- Running a reliable cron scheduler

- Operating an AI agent, or anything that connects to an unreliable or non-deterministic API.

What’s unique about DBOS’s take on durable execution (compared to, say, Temporal) is that it’s implemented in a lightweight library that’s totally backed by Postgres. All you have to do to use DBOS is “npm install” it and annotate your program with decorators. The decorators store your program’s execution state in Postgres as it runs and recover it if it crashes. There are no other dependencies you have to manage, no separate workflow server–just your program and Postgres.

One big advantage of this approach is that you can add DBOS to ANY TypeScript application–it’s just a library. For example, you can use DBOS to add reliable background jobs or cron scheduling or queues to your Next.js app with no external dependencies except Postgres.

Also, because it’s all in Postgres, you get all the tooling you’re familiar with: backups, GUIs, CLI tools–it all just works.

Want to try DBOS out? Initialize a starter app with:

    npx @dbos-inc/create -t dbos-node-starter

    npm install
    npm run build
    npm run start

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

Hi HN!

I've been fed up with search results so much that I decided to make a giant blocklist to remove garbage links by using uBlacklist.

I browsed other blocklists and wasn't very satisfied from what exists now; the goal of this one is to be super organized and transparent, explaining why each site was blocked via issues. Contributions welcome!

Even though around 100 domains are blocked so far, I already noticed a big improvement in casual searches. You'd be surprised how some AI generated websites can dominate the #1 page on DuckDuckGo.

Hey HN! I'm the author of News Minimalist — a news aggregator where all news is ranked by significance on a scale from 0 to 10.

The project was born out of personal pain — I wanted a way to read only significant news, like major humanity milestones, or historical political events, filtering out all the celebrity gossip and smartphone releases. But I couldn't find a way to do that — everywhere I looked, the news was ranked by popularity, coverage, or relevance, not significance.

I first tried to solve the problem in the beginning of 2023 with GPT-3 (the top model at that time) by asking it to estimate the significance of some news stories. The results were painfully bad — for some reason, the model preferred tragic, personal stories, completely missing the essence of what makes the news significant. No amount of prompt engineering could fix that.

But it all changed in March 2023 when GPT-4 came out. The scores it gave made much more sense. After a month of work, the first version was ready. News Minimalist had its first successful Hacker News post (https://news.ycombinator.com/item?id=35795388), and I realized that a lot of people had the same problem I had.

I've been working on improving the project ever since. As probably most tech founders, I spent too much time on technical improvements, completely ignoring marketing. But I think that work paid off, and I'm finally satisfied with the scores it gives.

The results are posted on the site: https://www.newsminimalist.com/

Let me know what you think!

Vadim

I figured this might be interesting for some here. This is a demo we built to showcase computation with Feldera (SQL compiled to Rust circuits that evaluate input incrementally): https://github.com/feldera/feldera

The gist of it is that if you update a cell, we incrementally update the spreadsheet which means we will only emit a minimal amount of changes for the cells affected by your update. The nice thing about it is that this is something that Feldera does automatically (and it would do that for any SQL that you end up writing, so it doesn't have to be a spreadsheet, but a spreadsheet is a nice example that everyone understands and knows about).

There is a more detailed explanation in this video https://www.youtube.com/watch?v=ROa4duVqoOs if you're interested what's going on under the hood -- or if you prefer reading about it we have an article series that goes over all the parts of the demo

1. Feldera SQL (gets compiled to Rust) https://docs.feldera.com/use_cases/real_time_apps/part1

2. API server (Rust/Axum hosted on fly.io) https://docs.feldera.com/use_cases/real_time_apps/part2

3. egui web Client (Rust compiled to WebAssembly) https://docs.feldera.com/use_cases/real_time_apps/part3

I made an open source directory for sharing projects

Ever wondered how to show off that something you just built? Look no further! Awesome Launch is meant to be a list of communities and forums you can share your projects to get feedback or your first users.

Anyone is free to contribute sites and resources. Hope you enjoy!

Simplex is an SDK that provides low-level functions you can use to create reliable web automations using code and natural language.

Here's a quick video to show you how it works: https://www.loom.com/share/8d27d0f9e0f34c77a81b0ac770151c12

A couple weeks ago, we needed a way to automatically find 3D assets from the internet for one of our work contracts. We didn’t need an AI to choose all the steps for us autonomously — we knew generally what the flow to find items should be and just needed some intelligence to handle different webpage formats.

Playwright couldn’t easily generalize to the different sites we wanted to search over and Claude computer use was tough to use — it was slow, expensive, struggled to click on the correct web elements, and there was no way to correct its actions if it failed at step 20 of our workflow.

So we built a vision-based solution using vision language models that sits on top of Playwright. In our SDK, building a function that can universally search websites is as easy as this:

    from simplex import Simplex
    simplex = Simplex(api_key="api_key")
    
    def search(website, search_query):
        simplex.goto(website)
        simplex.click("the search bar")
        simplex.type(search_query)
        simplex.press_enter()
        
    search("mit.edu", "alyssa p hacker")

We'd love feedback!

Hi HN!

Last year, we shared marimo [1], an open-source reactive notebook for Python with support for execution through WebAssembly [2].

We wanted to share something new: you can now run marimo and Jupyter notebooks directly from GitHub in a Wasm-powered, codespace-like environment. What makes this powerful is that we mount the GitHub repository's contents as a filesystem in the notebook, making it really easy to share notebooks with data.

All you need to do is prepend 'marimo.app' to any Python notebook on GitHub. Some examples:

- Jupyter Notebook: https://marimo.app/github.com/jakevdp/PythonDataScienceHandb...

- marimo notebook: https://marimo.app/github.com/marimo-team/marimo/blob/07e8d1...

Jupyter notebooks are automatically converted into marimo notebooks using basic static analysis and source code transformations. Our conversion logic assumes the notebook was meant to be run top-down, which is usually but not always true [3]. It can convert many notebooks, but there are still some edge cases.

We implemented the filesystem mount using our own FUSE-like adapter that links the GitHub repository’s contents to the Python filesystem, leveraging Emscripten’s filesystem API. The file tree is loaded on startup to avoid waterfall requests when reading many directories deep, but loading the file contents is lazy. For example, when you write Python that looks like

```python

with open("./data/cars.csv") as f: print(f.read())

# or

import pandas as pd pd.read_csv("./data/cars.csv")

```

behind the scenes, you make a request [4] to https://raw.githubusercontent.com/<org>/<repo>/main/data/car....

Docs: https://docs.marimo.io/guides/publishing/playground/#open-no...

[1] https://github.com/marimo-team/marimo

[2] https://news.ycombinator.com/item?id=39552882

[3] https://blog.jetbrains.com/datalore/2020/12/17/we-downloaded...

[4] We technically proxy it through the playground https://marimo.app to fix CORS issues and GitHub rate-limiting.

Hello and happy new year!

We're excited to introduce the Pyper package for concurrency & parallelism in Python. Pyper is a flexible framework for concurrent / parallel data processing, following the functional paradigm.

Source code can be found on [github](https://github.com/pyper-dev/pyper)

Key features:

Intuitive API: Easy to learn, easy to think about. Implements clean abstractions to seamlessly unify threaded, multiprocessed, and asynchronous work.

Functional Paradigm: Python functions are the building blocks of data pipelines. Let's you write clean, reusable code naturally.

Safety: Hides the heavy lifting of underlying task execution and resource clean-up. No more worrying about race conditions, memory leaks, or thread-level error handling.

Efficiency: Designed from the ground up for lazy execution, using queues, workers, and generators.

Pure Python: Lightweight, with zero sub-dependencies.

We'd love to hear any feedback on this project!

I've been working on this for a little bit and just got the site up off my own dev machine today. This is a site that uses the Gemini API to summarize HN posts and comments using Gemini 1.5 pro. It also tags stories using the Gemini API. Tags can be browsed for all stories that have that tag. All the tags annotated with the number of stories that have that tag are browsable. The web application portion is written in Django, backed by a Postgres database, served by gunicorn and ultimately pushed out through an nginx reverse proxy. I ended up making this because it was something that I wanted, I'm an old Slashdot nerd, always reading the stories and never the comments. I like HN, and the comment threads here, and wondered one day what it would be like to get Gemini to summarize posts in a way similar to Slashdot.

I don't have any plans to charge for the site. I will probably only have it pull stories once or twice a day to keep the API costs down. There are five API hits per story, verbose summaries (story and comments), tldr summaries (story and comments), and tags. Right now I've got a python script separate from the Django application that does all the interacting with the HN api (which is very nice by the way), the Gemini API, and the Postgres database. I ended up using the Gemini 1.5 pro model to do the summaries as it seems to have access to the Internet, while the other model I tried do not. Getting the model to consistently output JSON for the tags was a bit tricky, until I asked Gemini itself to fix up the prompt for consistently generating JSON. Now it seems to output valid JSON every time without a JSON prefix.

I have noticed that Gemini likes to hallucinate when it comes to the comments, I have it just about ironed out for the story URLs. Mostly when there are few or no comments it seems to summarize like the comments it expects to be there. I'll probably keep tweaking the prompts, and if there's interest demonstrated on Patreon I'll take some polls there of new features to add. I might add more summary types, Gemini seems to do an alright job when I tell it to critique an article but I haven't looked into that too deeply and I have a hunch it might start to hallucinate more. Setting up a personalized page with tag filtering might be an interesting thing to add.

Regardless, I hope you find it interesting. I'm personally curious which tags will end up with the most stories after I have it running for about a month or so. Questions and critiques welcome!

Cronevery.day is a website that provides a daily update on the status of Cron, a time-based job scheduler in Unix-like operating systems. The site offers a simple and straightforward way to check the health and uptime of Cron across various platforms.

I made a Doom source port that runs within a PDF file.

I was inspired by the recent HN post about Tetris in a PDF (https://news.ycombinator.com/item?id=42645218) and I wondered if I could get Doom to run using a similar method.

It turns out that old versions of Emscripten can compile C to asm.js code that will happily run inside the limited JS runtime of the PDF engine. I used the doomgeneric (https://github.com/ozkl/doomgeneric) fork of the original Doom source, as that made writing the IO fairly easy. All I had to do was implement a framebuffer and keyboard inputs.

Unlike previous interactive PDF demos, the output for DoomPDF is achieved by creating a text field for each row of pixels in the screen, then setting their contents to various ASCII characters. This gives me a 6 color monochrome display, that can be updated reasonably quickly (80ms per frame).

The source code is available at: https://github.com/ading2210/doompdf

Note that this PDF can only run in Chromium-based browsers that use the PDFium engine.

I’m an indie maker, just like many of you. A few months back, I launched a product on one of the big platforms, and... nothing. It got buried under dozens of other launches within hours. All that work, all that excitement is gone in the blink of an eye. No one even saw it.

It stung. I wasn’t mad, well, maybe a little but mostly, I just felt invisible. The truth is, indie makers like me don’t have big teams or budgets to fight for visibility. We rely on genuine support and connections. I couldn’t stop thinking about how many great ideas never get the attention they deserve because they’re overshadowed.

So, I decided to build something different: https://itslaunched.com

Here’s the idea:

• 10 launches per day, max. Limiting the number of daily launches ensures that every product gets its moment in the spotlight.

• 2 votes per user, per day. This isn’t a popularity contest. You only get two votes, so people have to really think about which products they want to support. It’s quality over quantity.

• “Under Radar” feature. This one’s my favorite. If a product doesn’t get much love on its launch day, it gets a second chance to shine the next day. Because timing shouldn’t be the only thing standing between you and success.

There’s more like badges, comments, streaks but the heart of it is simple: a fair shot for indie makers.

I built this because I believe every product deserves to be seen, especially the ones built by solo makers and small teams putting their heart into something they truly care about. And I didn’t build this to compete with Product Hunt. I built it to give indie makers the platform they deserve, one where their creativity truly gets noticed.

If this sounds like something you’d want to check out, I’d love your thoughts. I’m still tweaking and improving it every day based on feedback.

Let me know what you think and if you’ve got a product you’re proud of, I’d love to see it shine.

The article discusses the rise of outreach AI, a technology that uses machine learning to automate and optimize outreach campaigns for businesses. It explores how outreach AI can streamline marketing efforts, improve customer engagement, and drive better results.