Show stories

I’ve been experimenting with Rust lately and wanted a project that would help me explore some of its lower-level and performance-oriented features. Inspired by Sebastian Lague’s videos, I decided to implement my own ray tracer from scratch.

The initial goal was just to render a simple 3D scene in the browser at a reasonable frame rate. It evolved into a small renderer that can: • Run locally or on the web using wgpu and WebAssembly • Perform mesh rendering with a Bounding Volume Hierarchy (BVH) for acceleration • Simulate both direct and indirect illumination for photorealistic results • Be deployed easily as a free web demo using GitHub Pages

The project is far from perfect, but it’s been a fun way to dig deeper into graphics programming and learn more about Rust’s ecosystem. I’m also planning to experiment with Rust for some ML projects next.

GitHub: https://github.com/tchauffi/rust-rasterizer Web demo (desktop browsers): https://tchauffi.github.io/rust-rasterizer/

Would love feedback from anyone who’s built similar projects or has experience with wgpu or ray tracing in Rust.

We built a local-first, private, multi-currency, double-entry based personal finance app. It will help you track, visualize, and plan your financial journey. Use the `Try demo` button, to try it without an account. Small screens (mobiles) are not supported yet.

By local-first we mean, your data is on your system (we use sqlite over opfs, in browser). For synching across devices, the data is encrypted with your key before it leaves your device. You can backup the data locally (if you are using chrome) and/or to your dropbox. It's designed so that we (the people building it) can't access your data.

Why double-entry? Many personal finance apps operate on single entry model. But it quickly reaches limits with complicated set of transactions (returns on a house, your networth and a lot more). FinBodhi uses double entry so complicated set of transactions and accounts can be modeled (which happen often enough in users financial journey). We wrote about double-entry here: https://finbodhi.com/docs/understanding-double-entry

FinBodhi currently supports import, tracking, visualization and planning. There are few built in importers and you can define your own custom importer, apply rules to imports etc. You can slice and dice your transactions, split/merge transactions, associate them with accounts etc. We support cash and non-cache accounts. For non-cache mutual fund and stock accounts in Indian context, we can fetch price for you. For others, there is manual price entry. We also support multi-currency, and you can set price for currency conversions also. You can view reports like Balance Sheet, Cashflow, P&L and much more, and visualize data in various ways. And when you are ready, start planning for your future.

Eventually we would like the app to cover a users complete financial journey. There is a lot more that can be done (like mobile support, budgeting, price fetching, improved imports, ai integration and a lot more), but the current set of features is quite usable. We have written down our manifesto, which guides the overall development: https://finbodhi.com/docs/manifesto/

Please give it a try. All plans are free for now. Reach out to us at discord: https://discord.gg/mQx649P6cy

This article discusses the concept of the 'Internet of Things' (IoT) and its potential impact on various industries, highlighting the challenges and opportunities presented by the growing interconnectivity of devices and the increasing amount of data generated.

Hey HN,

I'm a pianist who's always been obsessed with understanding how great players think through harmony. What voicings are they using? How do they voice lead through changes? What's actually happening under their hands?

Back in 2022, I built Harmonic Analyzer (https://www.youtube.com/watch?v=iNgSgvUmiOs) – a Mac app that used ML to transcribe polyphonic piano recordings. It got some traction, but I never quite finished it. Requiring users to download a Mac app felt like unnecessary friction, and I didn’t want to limit distribution to Mac users.

I just shipped Pianolyze (https://pianolyze.com), a complete rewrite that runs entirely in the browser.

Tech stack:

• ONNX Runtime hosting Bytedance's piano transcription model (https://github.com/qiuqiangkong/piano_transcription_inferenc...) • Web Workers for async transcription, exposed via Comlink • WebGL for piano roll rendering • Web Audio API for playback • IndexedDB for model caching • React + MobX State Tree

Nothing leaves your device. No servers, no uploads, no inference costs.

Try it: Just drag and drop any solo piano recording (MP3, WAV, FLAC, M4A). The model downloads once (~100MB), and then everything runs locally. It works best with solo recordings; accompaniment can confuse the model. Chrome and Safari work best, on desktop.

I'd love feedback on the UX, performance on different hardware, and how well it handles various recordings. Also happy to discuss the technical approach.

Here it is in action, transcribing the great Mulgrew Miller: https://www.youtube.com/watch?v=sWW-Z9_n8Mk

Author here. pydoll is my attempt to build a modern Python automation library from first principles, based on asyncio. My main goal was to create a 100% type-safe API over the chaotic Chrome DevTools Protocol.

This was a massive undertaking that involved mapping the entire protocol to Python TypedDicts, which gives the user full IDE autocomplete for every command and event. I wrote about this type-safe architecture here: https://pydoll.tech/docs/deep-dive/fundamentals/typing-syste...

This design was necessary to build the advanced evasion features. To do that, I had to first understand how modern bot detection actually works, which sent me down a deep research rabbit hole. The result is a full technical encyclopedia on multi-layer fingerprinting, which I'm sharing as part of the docs: https://pydoll.tech/docs/deep-dive/fingerprinting/

The core thesis is that modern evasion isn't about randomness, it's about perfect consistency across this entire stack. Pydoll is the tool I built based on that thesis. It's open-source, and I'd love to get any and all technical feedback on the asyncio architecture, the type-safe API, or the research itself.

Built a developer-friendly BaaS around PostgreSQL + PostGIS. Instant APIs, real-time updates, self-hostable Docker image. Feedback welcome

This programming language, along with its IDE and tutorials, has been around for some time, but the TAB completion, which is helpful especially for beginners, is new.

Serie is a TUI application that uses the terminal emulators' image display protocol to render commit graphs like git log --graph --all.

This is not a full-featured git client, nor are there any plans to add such functionality, so it is not a replacement for tig, lazygit, gitui, etc.

The only purpose of this tool is to provide a pretty git log --graph and make commit information easily accessible.

While some users prefer to use Git via CLI, they often rely on a GUI or feature-rich TUI to view commit logs. Others may find git log --graph sufficient.

Personally, I found the output from git log --graph difficult to read, even with additional options. Learning complex tools just to view logs seemed cumbersome.

Limitations:

- Sixel is not supported. Only terminals that support the iTerm and kitty image protocols are supported.

- Terminal multiplexers are not supported.

- Windows is not supported.

https://github.com/lusingander/serie

For the last 6 months, I've been building ORUS Builder, an open-source AI code generator.

My goal was to fix the biggest issue I have with tools like v0, Lovable, etc. – they generate broken, non-compiling code that needs hours of debugging.

ORUS Builder is different. It uses a "Compiler-Integrity Generation" (CIG) protocol, a set of cognitive validation steps that run before the code is generated. The result is a 99.9% first-time compilation success rate in my tests.

The workflow is simple: 1.Describe an app in a single prompt. 2.It generates a full-stack application (React/Vue/Angular + Node.js + DB schema) in about 30 seconds. 3.You get a ZIP file with production-ready code, including tests and CI/CD config.The core is built on TypeScript and Node.js, and it orchestrates 3 specialized AI connectors for different cognitive tasks (I call this "Trinity AI").

The full architecture has over 260 internal components.

A bit of background: I'm an entrepreneur from São Luís, Brazil, with 15 years of experience. I'm not a programmer by trade.

I developed a framework called the "ORUS Method" to orchestrate AI for complex creation, and this is the first tool built with it. My philosophy is radical transparency and democratizing access to powerful tech.It's 100% MIT Licensed and will always have a free, powerful open-source core.

GitHub:https://github.com/OrusMind/Orus-Builder---Cognitive-Generat...

I'm here all day to answer technical questions, and I'm fully prepared for criticism. Building in public means being open to being wrong.Looking forward to your feedback. -- Tulio K

Hi everyone, we’ve been working on Safebox, an open-source framework that helps you install, manage, and access self-hosted applications such as Home Assistant, Nextcloud, and Jellyfin ect. Safebox runs on Linux, macOS, and Windows (supporting both x86 and ARM64 architectures, even Raspberry Pi, Banana Pi hardwares also tested). It manages domain and subdomain setup, Let's Encrypt certificates, DNS configuration, and reverse proxy (nginx). It also includes a WireGuard-based remote access feature and a geo-redundant backup system (currently in development). The project is in beta, and we’re looking for people interested in testing and sharing feedback. All information about Safebox and beta testing can be found in our Discord channel.

Try it using Docker: docker run --rm -v /var/run/docker.sock:/var/run/docker.sock safebox/framework-scheduler

Then open: http://localhost:8080

Links: Website: https://safebox.network/ GitHub: https://github.com/safeboxnetwork/framework-scheduler Discord: https://discord.gg/aBP8bz6N8J

We’d really appreciate any feedback or ideas for improvement.

The article discusses the development of Anki-LLM, an open-source project that integrates large language models (LLMs) into the Anki flashcard system, enabling users to leverage the knowledge and capabilities of these models for more effective learning and study.

I went down the rabbit hole on a side project and ended up building this: Strange Attractors(https://blog.shashanktomar.com/posts/strange-attractors). It’s built with three.js.

Working on it reminded me of the little "maths for fun" exercises I used to do while learning programming in early days. Just trying things out, getting fascinated and geeky, and being surprised by the results. I spent way too much time on this, but it was extreme fun.

My favorite part: someone pointed me to the Simone Attractor on Threads. It is a 2D attractor and I asked GPT to extrapolate it to 3D, not sure if it’s mathematically correct, but it’s the coolest by far. I have left all the params configurable, so give it a try. I called it Simone (Maybe).

If you like math-art experiments, check it out. Would love feedback, especially from folks who know more about the math side.

I spent a few hours last weekend testing whether AI can replace code by executing directly. Built a contact manager where every HTTP request goes to an LLM with three tools: database (SQLite), webResponse (HTML/JSON/JS), and updateMemory (feedback). No routes, no controllers, no business logic. The AI designs schemas on first request, generates UIs from paths alone, and evolves based on natural language feedback. It works—forms submit, data persists, APIs return JSON—but it's catastrophically slow (30-60s per request), absurdly expensive ($0.05/request), and has zero UI consistency between requests. The capability exists; performance is the problem. When inference gets 10x faster, maybe the question shifts from "how do we generate better code?" to "why generate code at all?"

I submitted this earlier but it didn’t get any traction. But it’s blowing up on Twitter, so I figured I would give it another shot here.

The system is quick and easy to setup and works surprisingly well. And it’s not just a fun gimmick; it’s now a core part of my workflow.

We’re Robin, Louis, and Thomas. Pipelex is a DSL and a Python runtime for repeatable AI workflows. Think Dockerfile/SQL for multi-step LLM pipelines: you declare steps and interfaces; any model/provider can fill them.

Why this instead of yet another workflow builder?

- Declarative, not glue code: you state what to do; the runtime figures out how. - Agent-first: each step carries natural-language context (purpose, inputs/outputs with meaning) so LLMs can follow, audit, and optimize. Our MCP server enables agents to run pipelines but also to build new pipelines on demand. - Open standard under MIT: language spec, runtime, API server, editor extensions, MCP server, n8n node. - Composable: pipes can call other pipes, created by you or shared in the community.

Why a domain-specific language?

- We need context, meaning and nuances preserved in a structured syntax that both humans and LLMs can understand - We need determinism, control, and reproducibility that pure prompts can't deliver - Bonus: editors, diffs, semantic coloring, easy sharing, search & replace, version control, linters…

How we got there:

Initially, we just wanted to solve every use-case with LLMs but kept rebuilding the same agentic patterns across different projects. So we challenged ourselves to keep the code generic and separate from use-case specifics, which meant modeling workflows from the relevant knowledge and know-how.

Unlike existing code/no-code frameworks for AI workflows, our abstraction layer doesn't wrap APIs, it transcribes business logic into a structured, unambiguous script executable by software and AI. Hence the "declarative" aspect: the script says what should be done, not how to do it. It's like a Dockerfile or SQL for AI workflows.

Additionally, we wanted the language to be LLM-friendly. Classic programming languages hide logic and context in variable names, functions, and comments: all invisible to the interpreter. In Pipelex, these elements are explicitly stated in natural language, giving AI full visibility: it's all logic and context, with minimal syntax.

Then, we didn't want to write Pipelex scripts ourselves so we dogfooded: we built a Pipelex workflow that writes Pipelex workflows. It's in the MCP and CLI: "pipelex build pipe '…'" runs a multi-step, structured generation flow that produces a validated workflow ready to execute with "pipelex run". Then you can iterate on it yourself or with any coding agent.

What’s included: Python library, FastAPI and Docker, MCP server, n8n node, VS Code extension.

What we’d like from you

1. Build a workflow: did the language work for you or against you? 2. Agent/MCP workflows and n8n node usability. 3. Suggest new kinds of pipes and other AI models we could integrate 4. Looking for OSS contributors to the core library but also to share pipes with the community

Known limitations

- Connectors: Pipelex doesn’t integrate with “your apps”, we focus on the cognitive steps, and you can integrate through code/API or using MCP or n8n - Visualization: we need to generate flow-charts - The pipe builder is still buggy - Run it yourself: we don’t yet provide a hosted Pipelex API, it’s in the works - Cost-tracking: we only track LLM costs, not image generation or OCR costs yet - Caching and reasoning options: not supported yet

Links

- GitHub: https://github.com/Pipelex/pipelex - Cookbook: https://github.com/Pipelex/pipelex-cookbook - Starter: https://github.com/Pipelex/pipelex-starter - VS Code extension: https://github.com/Pipelex/vscode-pipelex - Docs: [https://docs.pipelex.com](https://docs.pipelex.com/) - Demo video (2 min): https://youtu.be/dBigQa8M8pQ - Discord for support and sharing: https://go.pipelex.com/discord

Thanks for reading. If you try Pipelex, tell us exactly where it hurts, that’s the most valuable feedback we can get.

DeepFakeFusion is a platform that offers advanced AI-powered video editing and synthesis capabilities, enabling users to create highly realistic deepfakes and manipulated videos.

The article discusses various investment options, including diversification, fixed income investments, stocks, and real estate. It provides an overview of the benefits and risks associated with different investment strategies to help readers make informed financial decisions.

Google Docs for Python basically. For the past 4 months, I’ve been working on a full-stack project I’m really proud of called PyTogether; a real-time collaborative Python IDE designed with beginners in mind (think Google Docs, but for Python). It’s meant for pair programming, tutoring, or just learning Python together. It’s completely free. No subscriptions, no ads, nothing. Just create an account, make a group, and start a project. Has proper code-linting, live drawings for note-taking or teaching, voice chat, an extremely intuitive UI, autosaving, and live cursors. There are no limitations at the moment (except for code size to prevent malicious payloads).

Why build this when Replit or VS Code Live Share already exist?

Because my goal was simplicity (and education). I wanted something lightweight for beginners who just want to write and share simple Python scripts (alone or with others), without downloads, paywalls, or extra noise. There’s also no AI/copilot built in, something many teachers and learners actually prefer. Also its free lol

Tech stack (frontend): React + TailwindCSS CodeMirror for linting Y.js for real-time syncing and live cursors Skulpt to execute Python in the browser (for safety - I initially wanted Docker containers, but that would eat too much memory at scale. Skulpt has a limited library, so unfortunately imports like pygame wont work). I don’t enjoy frontend or UI design much, so I leaned on AI for some design help, but all the logic/code is mine. Deployed via Vercel.

Tech stack (backend): Django (channels, auth, celery/redis support made it a great fit) PostgreSQL via Supabase JWT + OAuth authentication Redis for channel layers + caching Fully Dockerized + deployed on a VPS (8GB RAM, $7/mo deal)

Data models: Users <-> Groups -> Projects -> Code Users can join many groups Groups can have multiple projects Each project belongs to one group and has one code file (kept simple for beginners, though I may add a file system later).

There were a lot of issues I came across when building this project, especially related to the backend. My biggest issue was figuring out how to create a reliable and smart autosave system. I couldn't just make it save on every user keystroke because for obvious reasons, that would overwhelm the database especially at scale. So I came up with a solution that I am really proud of; I used Redis to cache active projects, then used Celery to loop through these active projects every minute and then persist the code to the db. I did this by tracking a user count for each project everytime someone joins or leaves, and if the user count drops to 0 for a project, remove it from Redis (save the code too). Redis is extremely fast, so saving the code on every keystroke is not a problem at all. I am essentially hitting 4 birds with one stone with this because I am reusing Redis, which I've already integrated into my channel layers, to track active projects, and to also cache the code so when a new user enters the project, instead of hitting the db for the code, it'll get it from Redis. I even get to use Redis as my message broker for Celery (didn't use RabbitMQ because I wanted to conserve storage instead of dockerizing an entirely new service). This would also work really well at scale since Celery would offload the task of autosaving a lot of code away from the backend. The code also saves when someone leaves the project. Another issue I came across later is if people try sending a huge load of text, so I just capped the limit to 1 MB (will tinker with this).

Deployment on a VPS was another beast. I spent ~8 hours wrangling Nginx, Certbot, Docker, and GitHub Actions to get everything up and running. It was frustrating, but I learned a lot.

If you’re curious or if you wanna see the work yourself, the source code is here. Feel free to contribute: https://github.com/SJRiz/pytogether.

I’m still learning, so any feedback would be amazing (and contributions)!

An MIT-licensed human-friendly extension of JSON with quality-of-life improvements (comments, trailing commas, unquoted keys), extra types (tuples, bytes, raw strings), and semantic identifiers (think type annotations).

Built in Rust, with bindings for Python and WebAssembly, as well as syntax highlighting in VSCode. I made it for those like me who hand-edit JSONs and want a breath of fresh air.

It's at a good enough point that I felt like sharing it, but there's still plenty I wanna work on! Namely, I want to add (real) Node support, make a proper LSP with auto-formatting, and get it out there before I start thinking about stabilization.

The article discusses the Quibbler, a community-driven platform that enables users to collectively fact-check and debunk misinformation. It highlights the Quibbler's approach to combating the spread of false news through collaborative verification and transparent fact-checking processes.

The article discusses the Fuse Box Labels project, a tool that automatically generates SVG labels for Fuse Box bundles, making it easier to visualize the content and structure of complex web applications.

Hey HN! I’m a Product Manager and made a DIY doggy cam (using Claude and a Raspberry Pi) to help train my dog with separation anxiety. I wrote up a blog post sharing my experience building this project with AI.

Built on top of templUI - https://templui.io - (OSS), which I also created. goilerplate handles auth, subscriptions, docs, etc. SQLite by default, Postgres optional. Polar integration for payments. Feedback welcome!

I just started learning German, and it has been a frustrating experience, to say the least. There are so many seemingly arbitrary rules that make pattern recognition very difficult. Therefore, I have been looking for ways to make memorization a bit easier and fun. So, I came up with a bunch of games to make learning German a bit more engaging. Hope you find it useful as well!

The article discusses GT, a novel neural network architecture that aims to improve upon existing transformer models by introducing a gated token-mixing mechanism. The authors demonstrate GT's effectiveness on various natural language processing tasks and its potential for faster training and inference compared to standard transformer models.

I built this after seeing multiple teams accidentally ship API keys in their frontend code.

The problem: Modern web development moves fast. You're vibe-coding, shipping features, and suddenly your AWS keys are sitting in a <script> tag visible to anyone who opens DevTools. I've personally witnessed this happen to at least 3-4 production apps in the past year alone.

KeyLeak Detector runs through your site (headless browser + network interception) and checks for 50+ types of leaked secrets: AWS/Google keys, Stripe tokens, database connection strings, LLM API keys (OpenAI, Claude, etc.), JWT tokens, and more.

It's not perfect, there are false positives but it's caught real issues in my own projects. Think of it as a quick sanity check before you ship.

Use case: Run it on staging before deploying, or audit your existing sites. Takes ~30 seconds per page.

MIT licensed, for authorized testing only.

https://github.com/Amal-David/keyleak-detector

I built Open Canvas, another AI wrapper, but this time to your favorite whiteboard tools! Built on top of Excalidraw

The article describes a sandboxed environment for running step-by-step code, allowing for safe execution and exploration of algorithms without risking the main system. It focuses on the technical details and implementation of this sandboxed environment.

Hi HN,

For the past few months, I’ve been building UnisonDB — a log-native database where the Write-Ahead Log (WAL) is the database, not just a recovery mechanism.

I started this because every time I needed data to flow — from core to edge, or between datacenters — I ended up gluing together a KV database + CDC + Kafka.

It worked, but it always felt like overkill: too many moving parts for even small workloads, and too little determinism.

What is it?

UnisonDB unifies storage and streaming into a single log-based core. Every write is: • Durable (appended to the WAL), • Ordered (globally sequenced for safety), • Streamable (available to any follower in real time).

It combines B+Tree storage (predictable reads, no LSM compaction storms) with WAL-based replication (sub-second fan-out to 100+ nodes).

Key Ideas

1. Storage + Streaming = One System — no CDC, no Kafka, no sidecar pipelines

2. B+Tree-Backed — predictable reads, zero compaction overhead

3. Multi-Model — KV, wide-column, and large objects (LOB) in one atomic transaction

4. Replication-Native — WAL streams via gRPC; followers tail in real time

5. Reactive by Design — every write emits a ZeroMQ notification

6. Edge-Friendly — replicas can go offline and resync instantly

Performance & Tradeoffs 1. Write throughput is lower than pure LSM stores (e.g. BadgerDB) — because writes are globally ordered for replication safety. Deliberate tradeoff: consistency > raw write speed.

2. Still ~2× faster than BoltDB with replication enabled.

Tech Details

Written in Go

FlatBuffers for zero-copy serialization

gRPC for streaming replication

GitHub: https://github.com/ankur-anand/unisondb

Hi everyone,

I've built Chatolia, a platform that lets you create your own AI chatbots, train them with your own data, and deploy them to your website.

It is super simple to get started:

- Create your agent - Train it with your data - Deploy it anywhere

You can start for free, includes 1 agent and 500 message credits per month.

Would love to hear your thoughts,

https://www.chatolia.com