毎日の Show HN

Upvote0

2025年11月3日 の Show HN

31 件
95

a Rust ray tracer that runs on any GPU – even in the browser #

github.com favicongithub.com
29 コメント1:45 PMHN で見る
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.

40

FinBodhi – Local-first, double-entry app/PWA for your financial journey #

finbodhi.com faviconfinbodhi.com
21 コメント3:29 PMHN で見る
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

18

Serie – A rich Git commit graph in your terminal #

github.com favicongithub.com
2 コメント9:04 AMHN で見る
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

8

I built an AI that generates full-stack apps in 30 seconds #

13 コメント12:25 PMHN で見る
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

5

AgentML – Deterministic Language for Building Reliable AI Agents (MIT) #

github.com favicongithub.com
1 コメント8:41 PMHN で見る
Hey HN,

We’ve been experimenting with how to make AI agents more deterministic, observable, and production-safe, and that led us to build AgentML — an open-source language for defining agent behavior as state machines, not prompt chains.

My co-founder posted before but linked to the project website instead of the repo, so resharing here.

AgentML lets you describe your agent’s reasoning and actions as a finite-state model (think SCXML for agents). Each state, transition, and tool call is explicit and machine-verifiable.

That means you can:

- Reproduce any decision path deterministically

- Trace reasoning and tool calls for debugging or compliance

- Guarantee agents only take valid actions (e.g. “never send a payment before verification”)

- Run locally, in the cloud, or within MCP-based frameworks

Example:

```

<?xml version="1.0" encoding="UTF-8"?>

<agentml xmlns="github.com/agentflare-ai/agentml" xmlns:openai="github.com/agentflare-ai/agentml-go/openai" version="1.0" datamodel="ecmascript" name="researcher">

<datamodel>

    <data id="papers" expr="[]"
        schema='{"type":"array","description":"Fetched papers from Hugging Face"}' />

    <data id="summary" expr="''"
        schema='{"type":"string","description":"Summary of the papers"}' />
</datamodel>

<state id="start">

    <onentry>

        <log label="Researcher: "
            expr="`Fetching papers from Hugging Face and summarizing with OpenAI\n`" />

        <openai:generate model="gpt-4o" location="summary" stream="false">

            <openai:prompt>Summarize these recent AI/ML papers from Hugging Face:

                {{fetch "https://huggingface.co/api/daily_papers"}}

                Provide a concise summary of the key trends, breakthroughs, and developments in AI/ML research.
            </openai:prompt>

        </openai:generate>

    </onentry>

    <transition target="log_summary" />
</state>

<state id="log_summary">

    <onentry>

        <log label="Researcher Summary: " expr="summary" />

    </onentry>

    <transition target="done" />
</state>

<final id="done" />

</agentml>

```

We’re using this in Agentflare to add observability, cost tracking, and compliance tracing for multi-agent systems — but AgentML itself is fully open-source (MIT licensed).

Repo: https://github.com/agentflare-ai/agentml Docs: https://docs.agentml.dev

We also launched SQLite-Graph, a Cypher-compatible graph extension for SQLite, which will serve as the base for AgentML’s native memory layer. It’s also MIT licensed: https://github.com/agentflare-ai/sqlite-graph

Would love feedback from anyone building with LLM orchestration frameworks, rule-based systems, or embedded MCP tool servers… especially around how to extend deterministic patterns to multi-agent coordination.

— Jeff @ Agentflare

5

Extrai – An open-source tool to fight LLM randomness in data extraction #

github.com favicongithub.com
0 コメント7:14 PMHN で見る
A few months ago I was working on a flight search engine that would include pet transport costs (I know a few by hearth but storing them and make the calculations in the UI would be nice) While I was collecting pet pricing from several airlines I strugled to extract data in a common format without hallucinated values.

That's when I thought: What if I use multiple LLMs and take the most common response to improve accuracy?

This idea became this new project. You provide your documents, an SQLModel schema, an LLM provider, plus what you'd like to extract and Extrai does the rest. Including storing them in a DB afterwards.

There are a few other features such as SQLModel generation based on your documents, hierarchical extraction to manage nested objects more efficiently and built-in analytics.

Feedback is more than welcomed, since it's still a work in progress!

I built a landing page for people interested in a managed solution (I also had fun with threeJS!)

Let me know what you think

Landing page: extrai.xyz Github: https://github.com/Telsho/Extrai

5

PyTogether, open-source lightweight real-time Python IDE for teachers #

pytogether.org faviconpytogether.org
0 コメント3:01 AMHN で見る
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)!

4

Pianolyze – Learn any piano song using AI/ML, right in the browser #

pianolyze.com faviconpianolyze.com
1 コメント2:28 PMHN で見る
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

3

Secret Management for Local Development #

github.com favicongithub.com
0 コメント9:40 PMHN で見る
Hi HN,

I built a local secret management tool with Git-like workflows after almost committing production credentials one too many times.

Most secret management solutions are either: - Cloud-based (overkill for local dev) - GUI-heavy password managers (not dev-friendly) - Enterprise tools requiring infrastructure (Vault, etc.)

This is intentionally simple: version-controlled secrets with familiar Git semantics, running entirely on your machine.

Features: - Offline-first - Simple CLI - Encrypted storage - No cloud dependencies - Python API

Repo: https://github.com/athishrao/crux-vault

Happy to answer questions about the architecture, encryption approach, or why I thought building this at 2 AM was a good idea.

3

Pydoll, a type-safe asyncio lib for evading bot detection #

pydoll.tech faviconpydoll.tech
0 コメント2:27 PMHN で見る
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.

3

A react library for server racks and data networks #

react-networks-lib.rackout.net faviconreact-networks-lib.rackout.net
0 コメント2:28 PMHN で見る
I was in the middle of building a DC design/management tool (to automate various steps of the build, buy and management process in spinning up new sites) and needed to build a library for interactive design display. I'm considering making this available so others could use this component in their apps too.
3

Complete Claude Code Resource with 3-Minute Setup #

github.com favicongithub.com
1 コメント4:18 PMHN で見る
After 85 hours of work, I'm releasing a comprehensive Claude Code guide with automated setup.

What's different: It's honest about failures, real costs ($300-400/mo per dev), and realistic gains (20-30%, not 50%). Includes a "jumpstart" script that asks 7 questions and generates personalized setup in 3 minutes.

Includes 10,000+ lines of docs, production-ready agents (test, security, review), and templates. Not affiliated with Anthropic - just a developer sharing what works.

Feedback welcome!

3

Krnel-Graph, a Library for LLM representation engineering and control #

github.com favicongithub.com
1 コメント4:38 PMHN で見る
Hey HN! My co-founder and I built Krnel-graph, a library for training and evaluating lightweight probes based on LLM representations. In our experience, we found that LLMs have enough general world knowledge that we can build lightweight signals on top of them, so we built this library to bring this concept to more developers.

This is a link to some tutorial content we wrote about how to use our library for LLM guardrailing. It turns out that LLM representations can make for more accurate guardrails than purpose-built guardrails like LlamaGuard, and this post shows you how!

We’re especially looking for feedback. This library is open-source: no ads, no logins, no telemetry (yet), all self-hosted for now.

My company, Krnel, is hoping to provide value-add services on top of an open core. Please reach out if you’re looking for advice or contracting engagements!

3

JotChain – Get more out of your daily work notes #

jotchain.com faviconjotchain.com
4 コメント4:41 PMHN で見る
Hey HN,

I've been working in fast-paced startups for 10 years now, and I've noticed it's really hard to keep up with all the stuff I do. Sometimes it's tough to recall everything by the end of the week (EOW), and it's annoying when you have to show it off in a meeting or during a performance review.

I tried taking notes on paper, in Notion, Obsidian, Markdown files, and whatnot, but they all either got lost or I simply forgot to keep up with them.

That's why I decided to take action and build this small tool: JotChain. It lets you jot down quick notes throughout the day, then uses AI to turn them into polished summaries delivered via scheduled email notifications whenever you want them (e.g., right before your stand-up or weekly sync).

Here's how it works in a nutshell:

- Log wins, blockers, and context in a simple plain-text field (takes ~2 minutes, hit Cmd/Ctrl + Enter to save with optional tags).

- Set your cadence: daily, weekly, monthly, or custom, with timezone, lookback window, and lead time.

- Get AI-generated emails: Structured briefs with sections, key stats, and highlights (e.g., "Completed auth refactor, fixed 5 bugs, reviewed 12 PRs. Blocker: Database performance").

It turned out to be quite helpful for me, and I'm planning to introduce more features gradually to make building the habit even easier.

Free 14-day trial, no card needed. Plans start at $6/month or $36/year. Feel free to try it out and let me know what you think—what would make it better for your workflow?

3

Weak Incentives – lean, minimalistic toolkit for background agents #

github.com favicongithub.com
1 コメント4:48 PMHN で見る
A minimal, typed scaffold for agents: deterministic prompts, strict JSON, and a session that records plans, tool calls, and staged edits—so you can replay runs and ship audit logs.

* Deterministic Markdown prompt trees (dataclass input/output, tool contracts)

* On‑disk overrides with hash checks; Git‑root discovery

* Event bus (ToolInvoked/PromptExecuted), reducers, rollbackable session state

* Built‑ins: planning, sandboxed VFS, Python‑eval (via asteval)

* Optional adapters: OpenAI/LiteLLM conversation loop + JSON‑Schema outputs

3

WebAudio Data-Driven audio engine #

github.com favicongithub.com
1 コメント8:56 PMHN で見る
A couple years back, I found myself in my thirties with programming as my only real interest, and I felt this urge to reconnect with something else.

I used to play drums in high school bands, so I decided to get back into music, this time focusing on electronic music and keyboards.

One day, somehow I came across WebAudio and as a web developer, this clicked (not the transport one) to me. I was excited about the idea of working on a project with web and music at the same time. As a web developer who was heavily using REST APIs and state management tools, I started thinking of an audio engine that could be handled through data.

So Blibliki is a data-driven WebAudio engine for building modular synthesizers and music applications. Think of it like having audio modules (oscillators, filters, envelopes) that you can connect together, but instead of directly manipulating the modules, you just provide data changes. This makes it work really well with state management libraries and lets you save/load patches easily. Also, one other reason for this design is that you can separate the user interface from the underlying engine.

The project has grown into a few parts:

* Engine: The core WebAudio synthesis engine

* Grid: A visual interface where you drag/drop and connect modules

* Transport: Musical timing and scheduling system

I had a first implementation of Blibliki on top of ToneJS, but I started writing directly in WebAudio because I wanted to re-think my original idea, document and explain it to others. So, I documented the early steps in development process in a 4-part blog series about building it from scratch. Then I decided to abort the ToneJS project and continue with a complete re-implementation in WebAudio. In this way I learned many things about audio programming and synthesizers, because I lost many ready-to-use tools of ToneJS.

I'm not pretending this is the next VCV Rack or anything! It's got plenty of missing features and bugs, and I've mostly tested it on Chrome. But it works, it's fun to play with, and I think the data-driven approach is pretty neat for certain use cases. Currently, I'm in active development and I hope to continue this way or even better.

You can check it out:

Blibliki monorepo: https://github.com/mikezaby/blibliki

Grid playground: https://blibliki.com

Blog series: https://mikezaby.com/posts/web-audio-engine-part1

2

Safebox: Open-source framework for managing self-hosted apps (Beta) #

0 コメント10:23 AMHN で見る
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.

1

Microblogging with AI #

blog.micro.mu faviconblog.micro.mu
0 コメント2:30 PMHN で見る
Something basic to showcase. Write posts with AI basically. The idea is that you just enter a title and description and then hit "Write with AI" and it'll co-author the post with you and then you post it. Maybe it exists elsewhere but I don't really use X or other platforms anymore.
1

I built a tool that finds gaps in medical research #

researchthegap.com faviconresearchthegap.com
2 コメント12:33 PMHN で見る
I built Research the Gap, a free tool that maps medical papers on a grid using two of six research dimensions (Population, Methodology, Independent Variable, Outcome, and Setting). Green means well-studied, red means barely touched.

The idea came from a simple question: where do I find a research gap?

What do you think? And does the name make sense? Research the Gap, like Mind the Gap?