value: BSTRhino

value:
This is a game where you have to fight physics to get your dice in a row. Throw stacks of dice in the air to get the right ones along the bottom. In my opinion, this game feels really satisfying on a touchscreen, so try playing it on your tablet or phone if you have one! Still feels great with a mouse though too.
Just thought it'd be an intriguing use of a physics engine that HN might enjoy!
This game was created in 3 days for a gamejam. All music and artwork original. Made with Easel.

value: Show HN: Stack Masters – a physics-based Tetris-like dice stacking game

author: BSTRhino


value: lusingander

value:
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

value: Show HN: Serie – A rich Git commit graph in your terminal

author: lusingander


value: I developed an AI agent that controls a TurtleBot3 in the real world. The repository includes a demo video showing the TurtleBot3 following a prompt to move in a square shape, with each side 0.5 meters long. If you're interested, please have a look.

value: Show HN: AI Agent for a mobile robot in the real world


value: axadrn

value: 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!

value: Show HN: goilerplate – A SaaS boilerplate for Go and templ and Htmx

author: axadrn


value: adamclarke

value: Show HN: I built an SEO tool that uses embeddings to analyze content relevance

author: adamclarke


value: madjidbr

value: Show HN: Tired of memorizing file permissions, so I built chmod.info

author: madjidbr


value: drebora

value:
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.

value: Show HN: Safebox: Open-source framework for managing self-hosted apps (Beta)

author: drebora


value: Show HN: Claude Code disrupted programming. Bringing that power to office worker


value: grenishrai

value:
Hello Hacker News,
Wikipedia remains an invaluable resource for structured knowledge, yet its traditional search mechanisms can feel outdated in an era of conversational interfaces. AikiPedia addresses this by providing an open-source layer that integrates AI capabilities directly with Wikipedia's content, enabling more intuitive exploration and synthesis of information.
Overview
AikiPedia is a web application that leverages the Wikipedia API to access comprehensive documentation, enhanced by AI-driven tools for natural language interaction. It allows users to query, summarize, and personalize content without compromising on factual accuracy.
Key Features (v0.2)
* Natural Language Search: Submit queries in everyday language, such as "Explain blockchain for beginners," to retrieve Wikipedia-sourced results refined by AI for clarity and relevance.
* Generated Overviews: Produce customized summaries, comparison tables, or timelines from any topic, facilitating efficient research and knowledge distillation.
* Save and Share Functionality: Use local storage for bookmarking and exporting content in Markdown or PDF formats, with AI-assisted previews for easy dissemination.
Future enhancements will be guided by community feedback, potentially including voice-based queries, multilingual support, and collaborative annotation tools.
The platform ensures reliability by sourcing facts exclusively from Wikipedia's API, while employing the Gemini API for intelligent processing—minimizing errors and maintaining transparency in outputs.
I developed AikiPedia in a single evening, inspired by interactions with similar AI-augmented knowledge tools like Grokipedia. This project emphasizes an open-source, Wikipedia-centric approach, prioritizing ease of extension and deployment.
Technical Stack
* Frontend: Next.js 16 (App Router) with Shadcn UI, utilizing server-side rendering for optimal performance.
* Backend: NestJS 16 (App Router) for robust API management, including caching of Wikipedia responses and coordination of Gemini integrations.
* Storage and Integrations: LocalStorage for user data persistence; Gemini API (via Ai SDK) for AI functionalities; Wikipedia API for content retrieval.
* Deployment: Hosted on Vercel for scalable, edge-optimized delivery.
License: MIT, permitting unrestricted modification and redistribution.
Repository: https://github.com/Grenish/aikipedia. Live demo: https://aikipedia.vercel.app/
I welcome your insights: Any observations on usability, particularly across devices? Contributions via stars, pull requests, or issues are greatly appreciated.
Thank you for your time and consideration.

value: Show HN: AikiPedia – An Open-Source AI-Enhanced Interface for Wikipedia

author: grenishrai


value: TulioKBR

value:
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

value: Show HN: I built an AI that generates full-stack apps in 30 seconds

author: TulioKBR


value:
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, Setting and Study Location). 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?

value: Show HN: I built a tool that finds gaps in medical research


value: whatamidoingyo

value:
Hey everyone,
I recently started a local chess club. We had a few meetings already, and I've been winning a lot (heh). I thought it'd be a great idea to have the ability to keep track of games played, as well as give our members a local chess club rating.
I searched for open-source chess club management software, but couldn't find anything. It may be the case that it's just not something many people really look for or need, I guess.
It's still relatively new, I plan on implementing many more features and making it super easy to host. Let me know what you think! :)

value: Show HN: Open-Source and Free Chess Club Software

author: whatamidoingyo


value: darshanime

value:
Internally at our org, we have an ecosystem of over 200 microservices, implementing various parts of the business logic. To test any changes, we provide developers with on-demand sandboxed environments. One issue we had to solve for that was the creation of synthetic data across services, which respected the business rules and was coherent.
Today, we are happy to introduce datagen, a tool we developed internally to solve this problem. It generates coherent, synthetic data with the ability to model complex relationships. It is a new DSL (domain specific language) using which the user specifies the shape of the entity they wish to generate, and generator functions describing the logic for generating each field. The entity can be a table in a relational dbms, or a json document in a document store, or a csv file to upload on S3 etc.
The user writes models in .dg files that are transpiled to golang code, which can then be used to generate coherent, synthetic data.
Here is a simple example:

  // users.dg
  model users {
    fields {
      name() string
      age() int
    }
    gens {
      func name() {
        return "Arthur Dent" // hardcoded value
      }
      func age() {
        return IntBetween(18, 65)
      }
    }
  }

Checkout the website for more information: https://ds-horizon.github.io/datagen/
edit: demo video - https://www.youtube.com/watch?v=ly0DfzTup28

value: Show HN: Generate coherent, synthetic data at scale

author: darshanime


value:
Hey HN,
I’m a sexologist, and over the years I’ve noticed most men who think they have performance issues actually just have poor lifestyle habits — bad sleep, poor diet, heavy stress, no exercise, etc.
When you improve your lifestyle, your stamina naturally improves.
So I made this app to promote healthy lifestyle habits among men — in a funny way.

value: Show HN: I vibecoded an app that guesses how long you can last in bed


value: tchauffi

value:
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.

value: Show HN: a Rust ray tracer that runs on any GPU – even in the browser

author: tchauffi


value: thalissonvs

value:
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.

value: Show HN: Pydoll, a type-safe asyncio lib for evading bot detection

author: thalissonvs


value: matt-p

value: I built this while working on a data center design and management tool to automate parts of the build, buy, and deploy process for new sites. I needed an interactive visual component for rack and network design, I'm wondering if others would like to use this.

value: Show HN: React component for interactive server rack & network diagrams

author: matt-p


value: nickplee

value:
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

value: Show HN: Pianolyze – Learn any piano song using AI/ML, right in the browser

author: nickplee


value: asim

value: 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.

value: Show HN: Microblogging with AI

author: asim

title: Show HN: Microblogging with AI


value: JonasWiebe

value:
Since August I’ve been running a scoring system that tracks and ranks every new AI-related paper published on arXiv.
The goal is to detect genuine research events, things that move the field forward and filter out the usual noise and unsubstantiated uploads.
Each paper gets evaluated through a scoring algorithm.
The system then stores embeddings with structured fields like problem, approach, solution, and result for later retrieval.
Search runs on a hybrid model: it combines semantic embeddings with metadata like title, topic, author, and extracted keywords.
Queries return the most relevant and technically meaningful papers for a given concept.
So far, the data (since August) looks stable and the scoring aligns surprisingly well with expert-curated lists.
All of this is available through a free web interface and API.
Is this useful for everyday

value: Show HN: Free tool to explore daily AI research semantically

author: JonasWiebe


value:
Hi HN,
I worked with Françoise Lombaers, a mosaic artisan who's spent twenty years restoring heritage pieces, to explore what happens when algorithms meet traditional craft constraints.
We've been asking what happens when you try to implement algorithms with the constraints of traditional mosaic: square tiles only, never cut. It's not about making mosaics look "digital", it's about exploring how to create organic movement with square tiles and code.
We translated four different processes:
- Mycelium networks (fungal growth patterns)
- Prim-Jarník (minimum spanning trees)
- Conway's Game of Life
- Wave propagation
Process video: https://vimeo.com/1106384939
Individual Prim-Jarník piece: https://guillaumeslizewicz.com/studio/tesselles/
I am a designer and not a computer scientist, so this has been about understanding and taming the algorithms, then seeing what they become when embedded in tesserae.

value: Show HN: Four computational processes embedded in traditional mosaic


value: ebenes

value: Show HN: A pragmatic SQLite schema for application-level caching

author: ebenes


value: dotspencer

value: Show HN: Find matching acrylic paints for any HEX color

author: dotspencer


value: ciju

value:
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

value: Show HN: FinBodhi – Local-first, double-entry app/PWA for your financial journey

author: ciju


value: apignotti

value: Show HN: BrowserPod – Instant in-browser Node.js environments with public URLs

author: apignotti


value: Thumbpov.com is a simple and powerful tool to easily add text behind Images and Objects.

value: Show HN: An app to add text behind objects


value: johnmckinley

value:
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!

value: Show HN: Complete Claude Code Resource with 3-Minute Setup

author: johnmckinley


value: pbopps

value:
Hello,
I've been blogging on multiple platforms (Dev.to, Hashnode, Medium, Ghost) for the
past year. The biggest pain: reposting the same article 4 times with manual formatting
adjustments for each platform.
That's how AllPub was born.
The challenge wasn't the publishing—most platforms have APIs. The real problem was:
1. Each platform formats markdown differently
2. SEO metadata (titles, keywords, tags) need customization per platform
3. Notion → Platform conversion loses formatting/structure
4. Manual formatting errors are common
The solution:
- Connect your content source (for example notion, dev, hashnode)
- AI generates platform-optimized metadata
- Smart parsing converts content correctly for each platform
- One-click publish to all your platforms simultaneously
Tech stack: Next.js, Supabase, clerk, mailerlite, Vercel. Using Notion's official API + platform APIs
(Dev.to, Hashnode, etc).
We're currently in free beta and launching on Product Hunt Friday. Looking for early
feedback from the HN community before official release.
Biggest takeaway: Most developer tools fail not because the core idea is bad, but
because they underestimate platform-specific quirks and edge cases.
Beta: allpub.co
Questions about architecture, API integration, or Notion API weirdness? Happy to discuss.

value: Show HN: Tired of manually cross-posting articles? I built a solution

author: pbopps


value: chrka

value: 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.

value: Show HN: A beginner-programming language and IDE with helpful tab completion

author: chrka


value: gcr

value:
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!

value: Show HN: Krnel-Graph, a Library for LLM representation engineering and control

author: gcr


value: morozred

value:
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?

value: Show HN: JotChain – Get more out of your daily work notes

author: morozred


value: sagaruprety

value:
I built TabSmart because I was drowning in browser tabs and existing solutions weren't smart enough.
The problem: Most tab managers use simple heuristics—group by domain, or manual tagging. But when I'm researching software options, I'll have the vendor site, pricing articles from different blogs, reviews on Reddit, and demo videos on YouTube—all related but scattered across different domains.
TabSmart uses AI to actually understand what your tabs are about, not just where they're from. It analyzes page content (title + content extraction) and groups tabs that are semantically related, even if they're from completely different sites.
How it works:
- Extracts content from open tabs (configurable token limits)
- Sends to LLM (OpenAI, Anthropic, etc.) with a prompt to find relationships
- Returns structured groups based on semantic similarity
- Creates Chrome tab groups automatically
Technical details:
- Built as Chrome extension (manifest v3)
- Supports BYOK (bring your own API key) or managed service
- Customizable AI prompts for grouping logic
- Auto-group feature for continuous organization
- Privacy-focused: all processing happens server-side (or with your own key)
The interesting challenge was getting AI grouping to be both accurate and fast. Early versions would take forever with 50+ tabs. I optimized by batching tabs, using smarter content extraction, and caching.
You can try it here: https://chromewebstore.google.com/detail/tabsmart-ai-powered...
Built with vanilla JS, Supabase for auth/subscriptions, and Stripe for payments. Happy to answer questions about the implementation!

value: Show HN: TabSmart: AI-powered Chrome extension that groups tabs by context

author: sagaruprety


value:
I started working on a block explorer for fun and thought this was a good v1 to release to the public.
ChainKit is more low-level than other explorers like Etherscan and displays chain data fully.
There are also some nice features like contract storage slot visualisation and contract call simulations. My blog post explains it better: https://harishaji.com/posts/introducing-chainkit/

value: Show HN: Chainkit - low level block explorer built for developers


value: andreisavu

value: 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.<p>* Deterministic Markdown prompt trees (dataclass input/output, tool contracts)<p>* On‑disk overrides with hash checks; Git‑root discovery<p>* Event bus (ToolInvoked/PromptExecuted), reducers, rollbackable session state<p>* Built‑ins: planning, sandboxed VFS, Python‑eval (via asteval)<p>* Optional adapters: OpenAI/LiteLLM conversation loop + JSON‑Schema outputs

value: Show HN: Weak Incentives – lean, minimalistic toolkit for background agents

author: andreisavu


value: Show HN: I was tired of wasting engineer time on screening calls so I built Niju


value:
Hey HN,
Anyone here doing event marketing or spending time at offline events — trade shows, conferences, booths, etc.?
I’ve done my share of booth duty, and it was always hard, from TV loops with demo videos to collecting leads manually, running out of swag, trying to keep people engaged... you know the drill=)
So I built a tiny Mac app that automates a bunch of that:
– auto-plays content on TVs: product demos, slides, pics
– runs small interactive games (Trivia, SpinWheel, etc.) to draw attention
– collects leads from those games
– keeps track of your swag stock
Originally built it just to save my own sanity, but now I’m thinking it might be useful for others too.
Just deployed an LP for that and looking for a couple of design partners who actually run booths to test it out and see if it’s worth turning into a micro product.

value: Show HN: A Mac app to make booth life less miserable


value: Show HN: Bytebeat editor and player built with Zig and Raylib


value: cliftonk

value:
I built rstructor, a Rust library for structured LLM outputs. It's like Python's Instructor/Pydantic, but with the power and type-safety of Rust.
You define your data models as Rust structs/enums, and rstructor handles the rest: JSON Schema generation, LLM communication (OpenAI, Anthropic, etc.), parsing, and validation.
Example - extracting structured data from unstructured text:

    use rstructor::{Instructor, LLMClient, OpenAIClient, OpenAIModel};
    use serde::{Serialize, Deserialize};

    #[derive(Instructor, Serialize, Deserialize, Debug)]
    enum Severity { Low, Medium, High, Critical }

    #[derive(Instructor, Serialize, Deserialize, Debug)]
    enum IssueType {
        Bug { severity: Severity },
        FeatureRequest,
        Performance { ms_impact: u32 },
    }

    #[derive(Instructor, Serialize, Deserialize, Debug)]
    struct TriagedIssue {
        title: String,
        issue_type: IssueType,
    }

    let client = OpenAIClient::new(env::var("OPENAI_API_KEY")?)?
        .model(OpenAIModel::Gpt4OMini);

    // Performance issue example
    let perf_issue: TriagedIssue = client.materialize(
        "The login page takes about 500ms to load, which feels really slow compared to other pages."
    ).await?;

    // Bug report example
    let bug_issue: TriagedIssue = client.materialize(
        "When I enter an invalid email address, the login page crashes with a null pointer exception."
    ).await?;

    // Now you have type-safe data - leverage Rust's pattern matching
    match perf_issue.issue_type {
        IssueType::Performance { ms_impact } => {
            println!("Performance issue detected: {}ms impact", ms_impact);
        }
        IssueType::Bug { severity } => {
            println!("Bug found with severity: {:?}", severity);
        }
        _ => {}
    }

    Key features:
    * Support for OpenAI, Anthropic, Grok (xAI), and Gemini
    * Custom validation rules with automatic detection
    * Nested structures, arrays, and enums with associated data
    * Automatic retry with validation error feedback

Crate: https://crates.io/crates/rstructor
GitHub: https://github.com/clifton/rstructor
Docs: https://docs.rs/rstructor
Would love feedback from anyone building LLM-powered tools in Rust!

value: Show HN: Painless structured data from LLMs in Rust: rstructor

author: cliftonk


value: feskk

value: Show HN: Digital Ascetism, iPhone to Dumbphone

author: feskk


value: alanaan

value: Show HN: I built an edge ML system to detect and classify trick-or-treaters

author: alanaan


value: Show HN: The platform making SEO cheaper, simpler, and more effective


value: MarcellLunczer

value: Show HN: Neutral News AI – Multi-source, MNLI-checked news summaries

author: MarcellLunczer


value: gabika

value: We trained SLM-powered assistants for personal expenses summaries that you can run locally via Ollama. Out of the box, Llama 3.2 3B is correct only 24% of the time, while our fine-tuned models reach GPT-OSS 120B performance (up to 88%).

value: Show HN: Distil expenses – personal finance agent

author: gabika


value: JacobSingh

value: 30 second test, don't need to be a singer to try. Feedback please!

value: Show HN: An AI to match your voice to songs and artists you should sing

author: JacobSingh


value: memalign

value:
Hi HN! I just shipped a handful of educational games playable in your web browser. I hope you will give them a try and consider sharing them with the students in your life. I labeled each game with the target grade level (from TK up through middle school, and even high school for Spanish).
I've wanted to bring this style of educational game back to life for a long time.
In the early 90s, my grandmother had a Macintosh with educational games. She was a teacher who specialized in teaching reading. She showed me how to play Word Munchers and I had a blast munching words with the right vowel sounds.
Wolfers games should look good on phones, iPads, and can also be installed as progressive web apps on your home screen. I recently found a simpler way to make PWAs thanks to this minimal-pwa[0] project (via HN). I made this a bit more dynamic and self-contained in Wolfer's pwa.js and added offline PWA support in sw.js. I go as far as to dynamically generate the icon for each game variant using JavaScript. I didn’t realize browsers supported this!
I shared more development details and links to the source code here[1].
0: https://github.com/chr15m/minimal-pwa
1: http://memalign.github.io/p/wolfers.html

value: Show HN: Word Wolfer, Number Wolfer – educational games inspired by Munchers

author: memalign


value: Show HN: Vayno – AI Email Sequence Generator from Any Landing Page


value:
Hey HN
I built Vayno, an AI-powered email sequence generator that automatically creates full email campaigns from any landing page or product page.
Vayno uses AI marketing automation to read your page — offers, tone, audience, and calls to action — and turns it into ready-to-send email flows like:
Welcome series
Product launch campaigns
Abandoned cart reminders
Re-engagement sequences
Just paste your URL, and Vayno instantly generates professional, conversion-focused emails.
Built for founders, SaaS startups, and eCommerce marketers
 No templates — fully AI-personalized content
 Perfect for Shopify, Product Hunt, or email marketing automation users
Try it here → https://vaynoai.lovable.app
Would love feedback — especially from founders or marketers who write their own campaigns or use tools like Klaviyo, Mailchimp, or ActiveCampaign.

title: Show HN: Vayno – AI Email Sequence Generator from Any Landing Page


value: Arnaus

value:
I’ve built MyPCOptimizer, an AI-powered web tool for gamers and creators to analyze their PC hardware specs, detect bottlenecks, and get upgrade recommendations explained in simple language.
No signup required – just enter your specs, select a user profile, and see your diagnosis and actionable suggestions.
Built with React, TypeScript, Tailwind CSS, and Gemini AI.
Would love feedback, bug reports, and ideas for making hardware upgrades even smarter or more useful for non-technical users.
Try it out: https://www.mypcoptimizer.com/
Thank you!

value: Show HN: MyPCOptimizer – AI-powered PC hardware upgrade advisor

author: Arnaus


value: nullkevin

value:
I built Minuta - a minimalist session tracking app built with Vue 3 + Firebase Firestore.
Track focus sessions, tag your work, view simple analytics, and even more.
I built it because all tracking apps are:
1- either websites or apps and websites aren't responsive on phones
2- some critical features like tagging system locked under paywall
3- very poor user interface
I'm currently looking for contributors to help this project grow because I'm quite sure it has potential. I just started a few weeks.
Live version: https://minutatime.vercel.app/
Repo on GitHub: https://github.com/kevinmahrous/minuta
Also star it if you liked the project and hope you've an idea or two! :-)

value: Show HN: Minuta – track your work sessions, focus time, tag them, and more

author: nullkevin


value:
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

value: Show HN: Extrai – An open-source tool to fight LLM randomness in data extraction


value: arturwala

value: Show HN: React-like Declarative DSL for building synthetic LLM datasets

author: arturwala


value: Show HN: WordPress on GCP Cloud Run for $36/Month (Vs $59 on WP Engine)


value: ruben-davia

value: Show HN: An AI that keeps your internal documentation alive

author: ruben-davia


value: nullnotzero

value:
I built Russet, a chat app that uses Apple's foundation model (the same one powering Apple Intelligence) to run completely on-device.
Everything is private and offline. No internet needed, no account, no tracking. Your conversations never leave your iPhone/iPad/Mac.
Features:
- Privacy-first: Your data (prompts & responses) never leaves your device
- Uses Apple's foundation model sitting at the core of Apple Intelligence
- All processing happens locally on-device
Why "Russet"? Named after the humble potato because it's resilient and self-contained. After all, what good is intelligence without access?
Feedback welcome!
Requires Apple Intelligence to function

value: Show HN: Russet – Private AI companion using Apple's on-device foundation model

author: nullnotzero


value: Show HN: I made a static site generator framework to build personal websites


value: jeffreyajewett

value:
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:
```<p><?xml version="1.0" encoding="UTF-8"?><p><agentml xmlns="github.com/agentflare-ai/agentml"
 xmlns:openai="github.com/agentflare-ai/agentml-go/openai"
 version="1.0"
 datamodel="ecmascript"
 name="researcher"><p><datamodel><p><pre><code>    <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"}' />
</code></pre>
</datamodel><p><state id="start"><p><pre><code>    <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" />
</code></pre>
</state><p><state id="log_summary"><p><pre><code>    <onentry>

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

    </onentry>

    <transition target="done" />
</code></pre>
</state><p><final id="done" /><p></agentml><p>```
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

value: Show HN: AgentML – SCXML for Deterministic AI Agents (MIT)

author: jeffreyajewett


value: -i

value: I made a Wikipedia kind of website where you type the articles, every single word (case sensitive) you typed in the article is a hyperlink that goes to a "probably empty" page based on that word, once you go to the new page you can type an article for the new word, you can draw images for the articles using ASCii art, the website has a built in Ai bot to generate articles with you

value: Show HN: Infinite Info (I22.qzz.io)

author: -i

title: Show HN: Infinite Info (I22.qzz.io)


value: mesQuery

value:
I'm not gonna get into the politics of why we need decentralized p2p messaging, we already know that. What makes me angry is of all the people on earth, we're letting Jack Dorsey build decentralized messaging, in Swift.
I'm not a networking guy. But truly serverless P2P is dead simple to implement (if you let go of all the useful features...). Making it useful at internet scale without recreating all the infrastructure we're trying to escape? idk. I think it's possible, maybe because I'm stupid (most probably).
But at least I'm starting somewhere and I wonder how far I can take it. I'm sure there are existing solutions out there but at this point I don't care much.
I think I'll try to integrate DHT and NAT traversal next and move this to the internet. Bitchat is doing some bluetooth thing which I honestly don't see why.
Currently what I have is simple: No servers. No blockchain. No federation protocols. Just UDP multicast for discovery and TCP for messages. You run it on your LAN, and peers automatically find each other and can message directly.
it's cleartext over TCP, LAN-only, no NAT traversal, all the limitations.

value: Show HN: Peer-to-Peer Messaging

author: mesQuery

title: Show HN: Peer-to-Peer Messaging


value: mikezaby

value:
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

value: Show HN: WebAudio Data-Driven audio engine

author: mikezaby


value: ieuanking

value:
Built this with 3JS so I could visualize my own music for live sets - I added a demo song so you can play around with it.
Little clunky right now - some issues with the time selection/pausing and playing.
But trying to make it run in Ableton so I can control with a midi controller like my APC40, so I can change the visualizer live time during my live sets on stage.

value: Show HN: Visualizer Eden - 3JS audio visualizer

author: ieuanking


value: athish-rao

value:
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.

value: Show HN: Secret Management for Local Development

author: athish-rao


value: rodgetech

value: Show HN: 0forms

author: rodgetech

title: Show HN: 0forms


value: smalldezk

value: Quite many of my colleagues have been impacted with recent wave of tech layoffs (and I am not sure about my future as well - waiting for the news). The shock that people experience after hearing this news often paralyzes them and they do not know where to go and what to do. At the same time, the number of tasks one has to handle urgently (especially those who are on visa) is tremendous. To help people to deal with that, I have built a planner app with AI Copilot that can address questions + some (still basic) automation. The service is (and intended to always be) free for the impacted people. Please share your feedback and feel free to join me if you want to contribute with your ideas or code (the form is available on the website).

value: Show HN: LayoffKit – Free visa-aware planner for laid-off workers(AI+automation)

author: smalldezk


value: Show HN: Inspector Claude – explore your Claude Code sessions


value: Show HN: picomap - a data management tool for machine learning


value: I built DeepShot, a machine learning model that predicts NBA games using rolling statistics, historical performance, and recent momentum — all visualized in a clean, interactive web app. Unlike simple averages or betting odds, DeepShot uses Exponentially Weighted Moving Averages (EWMA) to capture recent form and momentum, highlighting the key statistical differences between teams so you can see why the model favors one side. It’s powered by Python, XGBoost, Pandas, Scikit-learn, and NiceGUI, runs locally on any OS, and relies only on free, public data from Basketball Reference. If you’re into sports analytics, machine learning, or just curious whether an algorithm can outsmart Vegas, check it out and let me know what you think: https://github.com/saccofrancesco/deepshot

value: Show HN: DeepShot – NBA game predictor with 70% accuracy using ML and stats


value: sushanttripathy

value:
We developed this solution after a B2B client ran into issues deploying production AI agents to speed up their customers’ onboarding.
Their UX: a customer enters their company homepage URL, and the agent autofills key fields (logo URL, case study URLs, etc.) to reduce manual form-filling and drop-offs.
The first version used ChatGPT and Claude in a relatively simple agent workflow. Once they started correcting frequent mistakes in critical fields (especially company logo URL and case study URLs), the system got more complex:
 • de novo crawling of the homepage URL
 • cross-checking every LLM response
 • multiple LLM calls per onboarding
Tokens per API call skyrocketed, pushing costs to about $0.80–$2.00 per call at ~1,000 queries/day, which wasn’t sustainable.
Our solution uses a combination of smaller language models running locally that consume outputs from pre-validated code snippets (for extracting URLs and other company details). A “reasoning” LLM selects which snippets to run at inference time based on the homepage content. This keeps most of the heavy lifting in deterministic code, with the LLM mainly orchestrating.
On a small initial test set of 30 URLs from the client, we returned accurate field values for 27/30. The workflow is noticeably faster end-to-end, and we charge a flat $0.25 per call (including crawling + extraction).
The agentic workflow is exposed via a WebSocket interface (JSON in/out). You can see it in action here, along with a free tester API key in the notebook:
 Google Colab: https://colab.research.google.com/drive/1AkLpL6IQoMDt6-aJwhT...
I’d love feedback, especially on:
 • obvious failure modes we’re not accounting for
 • fields you’d expect beyond those in the colab
 • whether per-call pricing vs. per-token pricing makes sense
If you want to try this in your own onboarding stack or have ideas for features, you can reach us at contactus@skymel.com.

value: Show HN:Cheaper Agentic API for Company Info from homepage (0.25$/call)

author: sushanttripathy


value: nenecmrf

value:
Far from ideal but works. Was really interesting to try how video players usually implemented
The project is opensourced, so feel free to contribute if needed.
https://github.com/kubarskii/streaming-video

value: Show HN: Created simple video sharing platform

author: nenecmrf


value: gpupromain

value: Show HN: [GPU-Pro] Master Your AI Workflow

author: gpupromain


value: chwiho

value: Show HN: Glitch Text Generator – Create stunning unicode text effects

author: chwiho


value:
I built a tiny tool to grab subtitles from any TikTok video. Paste a link, get captions instantly, then copy or download as .srt or .txt. It’s completely free and doesn’t require sign-in.
Why it might help:
- Note-taking and language learning without manual transcription
- Clean subtitle files for editing/remix workflows
- Multilingual UI and works with videos that already have captions
Limitations:
- If a video has no captions, nothing to extract
- Private/restricted videos may not work
- Occasional failures due to upstream/network—retry usually fixes it

value: Show HN: TikTok Transcript – free, no-login subtitles to .srt/.txt


value: darshanime

value:
Internally at our org, we have an ecosystem of over 200 microservices, implementing various parts of the business logic. To test any changes, we provide developers with on-demand sandboxed environments. One issue we had to solve for that was the creation of synthetic data across services, which respected the business rules and was coherent.
Today, we are happy to introduce datagen, a tool we developed internally to solve this problem. It generates coherent, synthetic data with the ability to model complex relationships. It is a new DSL (domain specific language) using which the user specifies the shape of the entity they wish to generate, and generator functions describing the logic for generating each field. The entity can be a table in a relational dbms, or a json document in a document store, or a csv file to upload on S3 etc.
The user writes models in .dg files that are transpiled to golang code, which can then be used to generate coherent, synthetic data.
Here is a simple example:

  // users.dg
  model users {
    fields {
      name() string
      age() int
    }
    gens {
      func name() {
        return "Arthur Dent" // hardcoded value
      }
      func age() {
        return IntBetween(18, 65)
      }
    }
  }

Checkout the website for more information: https://ds-horizon.github.io/datagen/
Demo video - https://www.youtube.com/watch?v=ly0DfzTup28

value: Show HN: Generate coherent, synthetic data at scale

author: darshanime


value: benthayer

value: I recently got locked out of an account that I deliberately set up to be airgapped from my password manager and that got me thinking how to make passwords less forgettable. After several iterations that led me to the concept of using a sequence of deterministically generated word grids where the grid depends on the previous words of your password and the next word of your password is one of the words in the grid. Instead of forgetting you can just vibe your way through the grids and recover your password like that. The passwords are longer to account for the entropy reduction from using the grid but I find it to still be a lot more memorable and pretty impossible to forget.<p>It basically just hashes the password and takes a mod of it to get the indexes in the word list for the next grid. You could easily make your own and integrate it with an existing system in like a day or two to replace passwords. You could also use the hashes as seeds to generate AI images if you wanted to iterate further and make it really distinctive. Could be interesting to see if users actually like it / want to use it. Probably makes more sense for airgapped/high security use cases like mine though.  What I built is just a proof of concept that I might use personally but I’d love for you to try it out and see what you think. Obviously you shouldn’t actually use it for your passwords since I could hypothetically be logging your data or take it down/change the algorithm but maybe it’s fun or cool or inspires you to build something similar

value: Show HN: I gamified passwords to make them easier to remember

author: benthayer


value: Show HN: Chess960v2 – Stockfish tournament with different starting positions


value: Comprehensive repository with pedagogical focus

value: Show HN: Polyglot standard library HTTP client C/C++/Rust/Python and benchmarks


value: Pedagogical article on creating docker development environments

value: Show HN: Polyglot Docker dev environment setup – C/C++/Rust/Python


value:
Hello,
For quite some time, I've been unsatisfied with the built-in timers on both Android and iOS; especially for workouts, when I needed to set up a configurable number of series with rest periods in between. That's when I started thinking about building something myself. It was just a timer and I said to myself "how hard could it be?", I had no idea.
The first iteration of the project worked "just fine", but the UI was an eyesore (even more than it is now), and the UX was quite awful as well. As you can probably guess, I'm not versed in design or front-end development. In fact, my last real experience with front-end work was back when jQuery was still a thing.
However, I knew what I wanted to build, and over the last few days (and with the help of the infamous AI) I was able to wrap up the project for my needs. It required quite a lot of "hand holding" and "back and forth", but it helped me smooth out the rough edges and provided great suggestions about the latest ES6 features.
The project is, as the title states, an offline-first PWA with zero dependencies; no build step, no cookies, no links, no analytics, nothing other than timers. It uses `Web Components` (a really nice feature, in my opinion, though I still don't get why we can't easily inherit styles from the global scope) and `localStorage` to save timers between uses.
I'd appreciate any comments or suggestions, since I just want to keep learning new things.
https://mytimers.app/

value: Show HN: MyTimers.app offline-first PWA with no build step and zero dependencies


value:
Hi Everybody
I made a open source AI Bot, which can generate txt/audio/photo/video content base on your chat content. try it here: https://github.com/yincongcyincong/MuseBot
my goal is make the best tg AI bot to help folks use it easier and more convenient.
please have a try.try Guanwushan_bot in telegram also work!
best regards

value: Show HN: A Golang Telegram AI Bot- make your TG bot more smarter


value: JoeOfTexas

value:
It's 3 weeks from Halloween and I decided to host a haunted garage at my house for our neighborhood.  I  drafted a layout of the garage, got donated decorations, spent $500 on amazon to transform the garage and found a great horror ambience on youtube.
Oh crap, its 1.5 weeks away now, and I need sound effects.  All the apps have prefilled spooky sound effects.  None of the apps let me auto-play sound effects, because I'm short on actors.
I do web dev, simple, I just make one.  Tadah, in about an hour I got a prototype.  In 4 hours I finished it.  I had some boilerplate already done to get it up on a URL.
Next actual sound fx...
1. Download a few from free soundfx sites.
2. Crap, I need specific ones, found ElevenLabs, and generated my own, and downloaded a few already generated by others.
3. Upload to R2
4. Hardcode into the throwaway webapp
5. The show is ON.
Got a good 2.5 hours of about 200+ people, and sometimes the sound fx lined up perfect with actors scaring our guests.  FUN!
Now, I'm showing it off on HN, before I throw it away.  Goodbye.

value: Show HN: Built a soundboard for my haunted garage with AI assistance

author: JoeOfTexas


value: thefarseen

value: Show HN: Neustream – Multistream to all platforms from one place

author: thefarseen


value: anticensor

value: Show HN: Fixing a VSCode performance issue present since the first commit

author: anticensor


value: CLCKKKKK

value:
Hi HN, I'm Kevin, co-founder of PivotHire AI.
We're building a platform to fix what we see as a core problem with freelance sites: clients spend more time managing freelancers than doing their own work.
Our approach is an "AI-Managed" abstraction layer. The key architectural decision is that clients and developers do not interact directly. Also, most talents are senior software developers from China that are cheap but high-value.
It's an event-driven workflow:
- A client submits a project goal in natural language.
- Our AI PM (built using LLMs) deconstructs the goal into concrete technical tasks, milestones, and deliverables.
- These tasks are routed to our vetted developer pool.
- The AI PM manages the entire lifecycle: progress tracking, check-ins, and validating deliverables before packaging the final product for the client.
The main technical hurdle we're tackling now is agent reliability. Getting it to correctly parse complex project info, monitor progress accurately, and trigger notifications via a VM-based system is non-trivial. The prompt engineering required for this kind of long-running, stateful project management is where most of our effort is.
Our stack: Next.js, Sass, shadcn/ui, and gpt-4.1-nano for the agent.
We're in the very early stages and would love to get your feedback on the core concept and our technical approach.
Homepage: https://www.pivothire.tech
Email: core@pivothire.tech
Product Hunt (for product preview): https://www.producthunt.com/products/pivothire-ai

value: Show HN: PivotHire – Project delivery service as easy as e-commerce platforms

author: CLCKKKKK


value: zachpark

value:
OpenAI's Apps SDK sucks.
So we built a better way to build ChatGPT apps, fast.
You can tap into 800M weekly active users, and early land-grab is everything.
200+ developers are already building with our framework.
Start with zero boilerplate and get:
- Interactive dashboards with real-time data
- Form widgets with validation + submission
- Data visualizations with charts & graphs
- API integrations with external services
- Authenticated widgets with user-specific data
Wanna make something?

value: Show HN: A framework 10x better than OpenAI Apps SDK

author: zachpark


value: nikitaeverywher

value:
Hello Hacker News!
I'm helping my friends to launch Jinna - your AI-mate built to get you paid faster.
Jinna lets you create invoices via voice, text, or file upload. Customize with logos, media, and payment links (with Stripe integration). The system automatically sends invoices and can follow up with configurable reminders based on your preferred timing and tone.
Happy to hear any feedback!

value: Show HN: AI Invoicing with Jinna – Create, Send and Chase to Get Paid Faster

author: nikitaeverywher


value: isakfiksdal

value: Show HN: Structa – Design databases in plain English with AI

author: isakfiksdal


value: gmzbri

value:
Hey everyone,
I recently built Artifacts, a platform to slow down and remember what lasts — to give meaning and story back to the things we hold onto.
Artifacts lets you:
• Explore a growing archive of thoughtfully curated objects
• Create your own digital inventory of things you own or want
• Connect with a community that values intentional owning
You can explore it at artifacts.is
Appreciate any feedback.
– Oscar

value: Show HN: Artifacts – Collect, share, and celebrate what endures through objects

author: gmzbri


value: boshenz

value: A crowdsourced map for ranking Boulder gym stinkiness and difficulty. Get a detailed view of the gym. “Is there toprope in the gym?” “Any training boards?”

value: Show HN: Yourshoesmells.com – Find the most smelly boulder gym

author: boshenz


value:
  ClipGuard is a cross-platform clipboard guard built with PySide6.

  Key features:
  - Monitors the clipboard in real time and keeps a searchable history.
  - Masks sensitive data (ID cards, bank cards, phone numbers, emails, IP addresses) and supports custom keywords.
  - Lists entries by source application, content type, favorites, and trash with full-text search.
  - Stores settings in ~/.clipguard/config.json and supports PyInstaller packaging.

  Repo: https://github.com/zhangshuo1991/ClipGuard

  I’d appreciate feedback on UI/UX, detection rules, and ideas for ML-powered features. Happy to answer questions!

value: Show HN: ClipGuard- A PySide6 clipboard guardian with masking and history search


value: rendylong

value: Show HN:When AI Agents Got File Systems: The First Step Toward Digital Labor

author: rendylong


value: AmuXhantini

value: Interested to see peoples thoughts about this. Feedback is welcome.

value: Show HN: TheSocialCompany – A New Social Experience

author: AmuXhantini


value: ile

value:
YouTube Auto-Focus
Automatically focuses the YouTube video player so keyboard controls work instantly (seeking back/forward and volume control).
To install: https://chromewebstore.google.com/detail/youtube-auto-focus/...
Source code: https://github.com/ile/YouTubeAutoFocus
--
YouTube Auto Subtitles
Selects auto-generated subtitles automatically.
To install: https://chromewebstore.google.com/detail/youtube-auto-subtit...
Source code: https://github.com/ile/youtube-auto-subtitles

value: Show HN: A couple of Chrome extensions to make YouTube better

author: ile


value:
Hey HN,
We’re building Concierge,
An open source framework that allows you to build Agentic Applications, letting LLMs navigate, interact, and transact with your service
It's a declarative framework which makes it easy for you to create Microservices for AI agents. You can expose your existing web offerings to LLMs. To support navigation you can use several abstractions like Stages, Tasks, Workflows and more. These specify the rules and guiding principles of how an Agent interacts with the service.
It's especially useful when you want to expose complex business logic with thousands of APIs, and want to provide context on how these can be used/called. For example building an Amazon for agents. With Concierge, you can several rules or "guiding principles" on how you want an Agent to interact with your service.
We are calling this new concept as Agentic Web Interfaces, would love to know what you think!
You can find the repository here: https://github.com/Agentic-Web-Interfaces/concierge
Some features we are excited about:
1. UI Dashboard to track costs, top business services, usage and analytics.
2. Replay ability to allow you to track and debug user sessions.
3. Ability to self-host or use our managed hosting.

value: Show HN: Concierge - Framework for Building Agentic Web Interfaces


value: areddyfd

value:
Hey folks! I'm a founding engineer at Yorph AI, an agentic data platform, built using ADK, that helps users (starting with product managers and analysts) join data from different sources (upload or sync), build version-controlled and reliable data workflows, and clean, analyze, and visualize data — all in one place.
We're also releasing semantic layer creation later this week.<p>The beta is live at yorph.ai/login — would love to hear your thoughts and feedback!<p>(FYI: We're still waiting on Google app verification — you'll see a warning for a few days. Dropbox shows a similar one since it's a new app.)

value: Show HN: Yorph AI – a data engineer in your pocket

author: areddyfd


value: Show HN: I Built a Prototype for a Universal Causal Language (UCL)


value: byx

value: This is a powerful online curve fitting tool that supports fitting dozens of commonly used functions and implicit functions. It features a clean interface and simple operation. If you need to perform curve fitting but don't want to learn professional software like Matlab or Origin, you can try this tool.

value: Show HN: An easy-to-use online curve fitting tool

author: byx


value: mattkevan

value:
Hi HN,
After trying to teach a non-technical friend how to manage a Jekyll site I decided there must be a way to make building a site with a SSG easier. Options like Decap, Contentful etc. do make it a bit easier but still take lots of tech knowledge to set up.
So I built Sparktype, a browser-based CMS that outputs statically-generated HTML and CSS. My goal is for it to be as easy to use as Substack or Medium, while providing all the benefits of a static site generator including openness, simplicity, speed, security and ownership.
It handles most things that you'd need from a CMS, including creating pages, image resizing, menu management, tags, collections, listings etc. I've only made two themes so far, but I'm working on a theme store and the ability to import custom themes.
Content is saved as plain Markdown + YAML frontmatter and JSON config files, so there's no lock-in and content is easily portable to other platforms. Generated sites can be exported as a zip file to upload via FTP, committed to Github or published via Netlify API.
I'm working on cross-platform client apps using Tauri which will enable more publishing options as its not limited by what can be done in a client-only environment.
The way the system works means that the Web doesn't need to be the only interface to the content - here's a simple Go-based CLI client that bypasses the HTML altogether https://github.com/sparktype-project/sparktype/tree/main/st-...
It's very early days and there are still plenty of bugs, but I'm posting now to hopefully get feedback and see what people think. Please do let me know!

value: Show HN: Sparktype – a CMS and SSG that runs entirely in the browser

author: mattkevan


value: zackriya

value:
Hey HN! I'm a maintainer of Meetily, an open-source meeting assistant that runs entirely on your machine.
The Problem: Current AI meeting tools (Otter.ai, Fireflies) require visible bots joining your calls and send all audio to their servers. This is awkward for client calls and impossible for GDPR/HIPAA environments.
How Meetily Works:
  • Captures system + microphone audio locally (no visible bot in meetings)
  • Runs Parakeet / Whisper.cpp for live transcription (GPU-accelerated)
  • Generates summaries via local LLMs (Ollama) or API (Claude/GPT)
  • Everything stays on your hardware – zero cloud dependency
Tech Stack:
  • Desktop: Tauri (Rust) + Next.js
  • Audio: System-level capture (no virtual cameras/bots)
  • Models: Parakeet, Whisper, Open source LLMs, OpenAi / Claude / Groq
  • Platforms: macOS, Windows, Linux (You might have to build. Build instructions available in Repo)
It's MIT licensed and designed for teams that can't send sensitive data to third parties (Gov, legal, healthcare, finance).
GitHub: https://github.com/Zackriya-Solutions/meeting-minutes
Website: https://meetily.ai
Would love feedback on the architecture, especially around audio capture reliability and model performance trade-offs!

value: Show HN: Meetily – Bot-free, self-hosted AI meeting notes-100% local processing

author: zackriya


value: x-fifteen

value: DiaryPal lets your diary travel. Write about your day and get automatically matched with someone across the world to exchange entries. Only you and your match can read each other’s diaries—no public posts. React with stamps or a short note, build a simple habit, and discover everyday perspectives you’d never see otherwise. Works on mobile and desktop, available in English and Japanese, and free to use.

value: Show HN: DiaryPal -Share Your Diary

author: x-fifteen

title: Show HN: DiaryPal -Share Your Diary


value: stavros

value: I have lots of free time.

value: Show HN: I made a website that vibe-codes itself

author: stavros

story_text: I have lots of free time.


value: zchmael

value:
Hey HN,
I'm Zack, CEO at Averi. We just launched what we're calling The AI Marketing Workspace—a complete rebuild of how we think marketing teams should work with AI.
Most AI marketing tools solve for one narrow use case:
-AI copywriting tools that spit out generic content
-Strategy platforms that stop at recommendations
-Analytics dashboards that show what happened but don't help you act
Our Approach: Workspace > Tool
Instead of building another point solution, we built a workspace that enables complete marketing workflows: Plan → Create → Execute → Scale.
What that means:
Plan: AI-powered strategy and planning with your brand context built in. Activate expert strategists when needed.
Create: /create mode takes briefs to deployment-ready assets. Collaborate with specialists in real-time.
Execute: Deploy with full context preserved. Experts see your strategy, drafts, and brand.
Scale: Library captures what worked. Every project trains the AI and makes future work faster.
What We Built
/create Mode: Three-Phase Creation Engine
The execution system at the heart of the workspace.
Discuss Phase:
Brief the AI with contextual questions specific to each asset type
Draft Phase:
AI generates first draft using Synapse architecture (routing between AGM-2, GPT-5, Claude based on task)
One-click adjustments to length, vibe, or language
Full draft regeneration with preserved context
Edit Phase:
Standard text editor with AI power-ups
Highlight any text → regenerate with AI
Add AI-generated paragraphs, images, infographics between sections
Full collaborative editing
Output:
Save as .AVRI files (native format maintaining full editability and AI context)
Download in standard formats
Share with experts in the workspace for refinement
The Workspace Architecture
Brand Core: Central repository for mission, values, brand voice, ideal customers, goals. Trains the AI and provides persistent context across all interactions.
Library System:
System Folders: Marketing Plans, ICPs, Products, Saved AI Conversations
Custom Folders: Organize content however you want, train AI on specific contexts
.AVRI files open directly in edit phase for seamless collaboration
Expert Network Integration: Type /intro to request vetted marketing specialists. Review profiles, activate experts, collaborate in the workspace.
What Makes This Different
1. Complete workflow, not isolated tasks: Most tools solve for one phase (strategy OR creation OR execution). Averi enables the full flow with persistent context throughout.
2. Context-aware by design: The AI doesn't just respond to your prompt. It knows your brand, your active plans, your audience, your goals—and maintains that context.
3. Execution-first: We don't stop at suggestions or strategy. The workspace takes you from first thought to deployment-ready assets to measurable results.
4. AI + Human, built in: Expert collaboration isn't a separate marketplace—it's native to the workspace.
5. Compounding institutional memory: Library and .AVRI files create a feedback loop. Every successful project makes future work better.
Open Questions We're Exploring
1. Workspace vs. Tool Mental Model: How do you get users to think of this as "where they work" vs. "a tool they use for 10 minutes"? We've found the multi-tab interface helps, but curious about other approaches.
2. File Format Ecosystem: We're betting that .AVRI files (maintaining full AI context + edit history) become a standard for marketing collaboration.
3. Self-Serve Conversion: We just opened self-serve today. Historically we were demo-driven. Interested in what others have learned about freemium → paid.
4. Integration Strategy: We're building integrations to CMS, email platforms, social schedulers. Question: do users want to push directly from Averi, or prefer to download and upload themselves?
Try It
Sign up: https://averi.ai
Thanks!
Zack

value: Show HN: Averi – The AI Marketing Workspace

author: zchmael


value:
I noticed that when onboarding new employees, a common approach is to send a Notion doc with a list of setup steps. But what if you want to know exactly where a new employee is at with their onboarding journey?
It's like you want to be able to configure a checklist, and map it 1:many onto different instances per-recipient, each with their own progress state.
I built TasksList as a way to address this general problem. Feedback encouraged!

value: Show HN: I made a lightweight way to send tasks to others


value:
I've created a DuckDB extension that allows you to work with Kaggle datasets directly inside DuckDB. It's called Gaggle and is implemented in Rust. It's not published on DuckDB's community extensions repository yet, but you can download the latest pre-built binaries from here: https://github.com/CogitatorTech/gaggle/releases
Project's GitHub repository: https://github.com/CogitatorTech/gaggle

value: Show HN: Gaggle – A DuckDB extension for working with Kaggle datasets


value: takennap

value: Show HN: A Other Word Game, Inspired by the New Yorker's Shuffalo

author: takennap


value: jmoyson

value:
I made Coldr after my last SaaS (Verifio) got zero traction. The target audience wasn't on Twitter or Product Hunt or this kind of platform (French property managers who needed direct outreach).
So I wanted to try some cold-email stuff (Tried cold calls... not for me AT ALL).
I tried the big tools out there, most of them required 10-step onboarding, credit cards for ‘free trials,’ and complicated dashboards setup... too much for what I needed: send 30 emails/days and get back to building.
So I made a CLI that works with plain files:
- `$> coldr init` –> creates leads.csv, template.html, config.json, suppressions.json
- `$> coldr schedule` –> schedule emails on Resend
I also added a few very simple features:
- CSV-based "A/B testing" (columns: subject, intro, variant)
- Writes scheduled_at, resend_id, status back to CSV to check
- Respects workdays/hours, randomizes send times, rate limits
It's minimal on purpose. Built for me and other builders who need to send 10-50 emails, not sales teams running 10K emails/day campaigns.
Demo → npx @jmoyson/coldr@latest hello (Just a fake campaign used for my demo)
Open to feedback and questions.

value: Show HN: Coldr – Run small cold email campaigns from your terminal

author: jmoyson


value:
Hi HN - I’m the developer of PingStalker, a macOS utility I built to see what’s really happening on the LAN/WLAN.
I live in the CLI, but when it came to discovery and monitoring, I found it limiting. So I built a GUI that brings my favorite tools together in one place.
PingStalker started because I wanted to know if something on the network was scanning my machine. I also wanted quick access to core details—external IP, Wi-Fi data, and local topology. Then I wanted more: fast, reliable scans using ARP tables and ICMP.
As a Wi-Fi engineer, I couldn’t stop there. I kept adding ways to surface what’s actually going on behind the scenes.
A few highlights:
- Performs ARP, ICMP, mDNS, and DNS scans to discover every device on your subnet, showing IP, MAC, vendor, and open ports.
- Continuously monitors selected hosts (“live ping”) to visualize latency spikes, missed pings, and reconnects.
- Detects VLANs on trunk or hybrid ports, exposing when your Mac is sitting on a tagged interface.
- Captures just the important live traffic — DHCP events, ARP broadcasts, 802.1X authentication, LLDP/CDP neighbor data, ICMP packets, and off-subnet chatter — to give you a real-time pulse of your network.
- Decodes mDNS traffic into human-readable form (that one took months of deep dives, but the output is finally clear and useful).
- Built my own custom vendor-logo database: I wrote a tool that links MAC OUIs with their companies, fetches each vendor’s favicon, and stores them locally so scan results feel alive and recognizable.
Under the hood it’s written in Swift. It uses low-level BSD sockets for ping and ARP, plus Apple’s Network framework for interface enumeration. The rest relies on familiar command-line tools. It’s fast.
I’d love feedback from anyone who builds or uses network diagnostic tools:
- Does this fill a gap you’ve run into on macOS?
- Any ideas for improving scan speed or how traffic events are visualized?
- What else would you like to see?
Details and screenshots: https://pingstalker.com
Happy to answer any technical questions about the implementation, Swift APIs, or macOS permission model.

value: Show HN: PingStalker – A macOS tool for network engineers


value: zesfy

value: Show HN: I built a local-first daily planner for iOS

author: zesfy


value: thatguywho

value:
Lately, I’ve noticed people using tools like Interview Copilot. These tools tell you what to say during a live interview. The AI listens and types an answer for you to repeat.
That seems wrong. If you get the job that way, what happens next? You can’t have AI feeding you answers in every meeting. Also, most interviewers can spot when someone is delivering rehearsed, robotic lines.
I understand why people turn to it. Interviews are stressful. You might freeze up, ramble or forget what you actually know. But AI should help improve your skills, not do the work for you.
That's why I created MockXP, an AI interview prep app. It allows you to practice unlimited mock interviews, receive instant feedback and track your progress until you sound confident and natural. It uses models that focus on real interview patterns, not generic Q&A bots.
Think of it like sparring before a big fight; you develop muscle memory instead of relying on a teleprompter.
I’m curious what HN thinks. Is using AI during interviews crossing a line, or is this the direction we’re heading?
App Store link - https://apps.apple.com/us/app/interview-prep-ai-mockxp/id675...

value: Show HN: MockXP – AI that helps you prepare for interviews, not cheat them

author: thatguywho


value: crazycreatives

value: Blends in realtime web-sockets and music instruments together. Allows users to play and hear what others are playing.

value: Show HN: Realtime socket based music instruments

author: crazycreatives


value: signumflow

value:
Hi HN!
I built SignumFlow — an API-first engine for approval workflows + smart routing.
Most approval + e-signature tools are UI-first. SignumFlow is developer-first:
you call the API, bring your own UI, and keep everything inside your product.
Highlights
• Create + execute approval workflows (sequential/parallel)
• Smart routing
• E-signatures
• Webhooks + audit log
• Templates
Docs → https://docs.signumflow.com
Early build — would love feedback on the API + use cases.

value: Show HN: API-first approval workflows and smart routing (SignumFlow)

author: signumflow


value: raghukumar

value:
Hi everyone,
I built this app to scratch my own itch, as I always struggled with a cluttered Gmail inbox and sometimes missed important emails within my Updates or Social tab.
I always felt jittery about using other apps, because almost all of them use OAuth for gaining access to a user's Gmail account. The OAuth token essentially means the app owners could do anything with my emails - read, delete, send on my behalf. I wanted to build something that worked without OAuth and created Clear Mail that simply executes javascript locally to declutter user's Gmail inbox.
I would love to hear your feedback/comments on my app.
The burning question I have is: How important is privacy for you when it comes to your email?
Would you prefer something that runs locally, or do you trust the established apps that use OAuth, since they’re already widely used? Thanks!

value: Show HN: Clear Mail for Gmail – Clean up your Gmail inbox locally, no OAuth reqd

author: raghukumar


value: rofko

value: Show HN: A CSS-Only Terrain Generator

author: rofko

title: Show HN: A CSS-Only Terrain Generator


value: caravel

value: Show HN: Agor → Figma for AI Coding (Open Source)

author: caravel


value: IdreesInc

value:
Source code available here (as part of my other feed): https://github.com/IdreesInc/Indie-Tech-Bluesky-Feed
The feed subscribes to the bluesky firehose and keeps track of trending posts grouped by each lyric. It then sorts each group using the hacker news algo score (almost like each word is a mini feed) and stitches them together. The result is a feed where every post starts with the lyrics to Never Gonna Give You Up and is dynamically updated like any other trending feed. Not exactly revolutionary, but it was a fun thing to try out.

value: Show HN: I made a Bluesky algorithm that Rick Rolls you with trending content

author: IdreesInc


value: Show HN: PACR - All-in-one academic ecosystem and professional social network


value: Show HN: In Memoria – MCP server that stops AI assistants from forgetting


value: benjah

value:
Could I get some opinions on my experiential learning language app?
When I learned Japanese with new friends, I didn't know how to ask where we were going or where the bathroom was.
It was really motivating. As in-country immersion isn't option in most cases, language exchange is next best option.
However, in-person language exchange can be expensive or difficult to schedule.
So I built ConvoLive to make language practice more engaging for myself.
Open Beta on Android and iOS
https://convolive.com
Technically interesting bits:

  - Lip-synced avatars using WebGL.
  - Continuous speech recognition on recent phone models so you don't have to press to speak
  - Using device speech recognition and caching assets means that most external LLM calls are limited to the free-form chat mode.
  - Unfortunately, on-device local LLM ended up being too demanding and slow.
  - GPT 4o provided better speed and results than GPT 5.
  - Multimodal quiz system with drag-and-drop, fill-in-the-blank, and multi-choice exercises
  - Freeform conversation gives you suggestions to keep the chat going, but you can also ask how to say something.

What works:

  - People seem to love or hate the avatars.
  - Testers are saying they feel more comfortable speaking.
  - The avatars aren't groundbreaking but they do make it feel less like talking to a chatbot.
  - Being able to speak freely without clicking seems more natural.

What doesn't:

  - People seem to love or hate the avatars.
  - As an app that promotes speaking out loud, people might be wary of speaking as a beginner outside their home.
  - The app might be better suited for people who already understand fundamentals like tenses or different alphabets which don't fit into a per conversation approach.
  - Newer better quality TTS models do not provide the viseme lip sync data I need for animation.

Currently supports Spanish, Japanese, Italian, German, Portuguese, and French.
Curious what other language learners here think – is this approach useful or do we not want to talk to our phones in broken Spanish?
Should I keep working on this?

value: Show HN: Built a conversational language learning app with Expo/WebGL/LLMs

author: benjah


value:
Built https://ballxpit.net/ for BallXpit players tired of scattered game help—no sign-ups, just actionable tools:
Match win strategies (nail late-game comebacks, optimize team plays).
Player build tips (stats, gear picks to speed up progression).
Weekly event breakdowns (fresh for this round’s challenges).
Made by a fellow player—feedback on adding stats trackers or team comp ideas?

value: Show HN: Ball X Pit Companion – Free Guides and Tips for the Roblox Sports Game


value:
Hi HN,
I built a library called Duron that provides the core building blocks for a durable execution engine, built on deterministic log replay and a custom asyncio loop.
To better support interactive workflows—such as human-in-the-loop interactions, streaming progress updates, and real-time inputs—I'm experimenting with two new primitives: signals and streams.
Key features:
- Asyncio-native: Custom asyncio loop that works seamlessly with standard primitives like `asyncio.timeout`, `asyncio.gather`, and `asyncio.sleep`
- Minimal dependencies: Zero external dependencies, pluggable log architecture for easy integration
- Interactive workflows: Streams and signals enable real-time communication between workflows and host applications
- Stateful effects: Generator-based effects with automatic checkpointing and state accumulation
Example use cases:
- Building custom durable workflow engines with minimal overhead
- Interactive workflows requiring human approval or external triggers
- AI agents with long-running conversations that persist across restarts
GitHub: https://github.com/brian14708/duron
I’m still iterating on the API design and stress-testing durability guarantees. Feedback, critiques, and ideas for real-world use cases are all welcome!

value: Show HN: Duron – Library for Building Durable AI Agent and Interactive Workflows


value: MyPasswordChecker - Free Password Strength Checker and optional Quantum Password Strength Checker with Phonetic Password builder. API for all 3 services available @ https://mypasswordchecker.com/password-api  OR for documentation visit https://mypasswordchecker.com/docs

value: Show HN: MyPasswordChecker – Quantum & Free Password Strength Checker


value: Show HN:chess960v2–over 55 rounds played, some starting positions are undefeated


value: Show HN: Debug your agents locally in real-time


value: mchab

value:
We just launched Deep-ML Labs, a new section on Deep-ML
Each Lab is a hands-on challenge where you implement parts of real models, activations, layers, optimizers, normalization, even small transformers — directly in PyTorch (and sometimes NumPy).
You can test your implementations on actual datasets, see how your results compare to others, and understand what’s really happening under the hood of deep learning frameworks.
let me know what you guys think and if we should work on making more of these questions

value: Show HN: Deep-ML Labs:Learn machine learning by building it from scratch

author: mchab


value: Utharian

value:
### *BonepokeOS: Refusal-Aware Creative Activation*<p>*~1500 lines. No dependencies. Copy-paste ready.*<p>#### *What This Isn't*
Another AI safety framework. Another content filter. Another attempt to make LLMs more "helpful" and "harmless."<p>#### *What This Is*
A *cognitive scaffold* that treats contradiction as a feature, not a bug. A system that breaks the "Cohesion Trap" by rewarding structural tension, not surface-level agreement.<p># Slightly more concrete demo
from bonepoke_core import BonepokeBrain<p>brain = BonepokeBrain()
result = brain.process_story_need(
    "Explain quantum entanglement using cooking metaphors"
)
print(f"β-Score: {result.metrics.contradiction_bleed:.2f}")  # 0.0-1.0 scale
print(f"Fatigue: {result.metrics.motif_fatigue:.2f}")
print(f"State: {result.state}")  # 'SALVAGE' = optimal creative tension
```<p>#### *The Three Metrics That Matter*
- *β (Contradiction Bleed)*: How much productive tension exists
- *ℰ (Motif Fatigue)*: How repetitive and predictable the output is
- *LSC (Local Semantic Coherence)*: Whether it makes sense locally despite global paradox<p>#### *Why This Exists*
Because current LLMs are stuck in a *Cohesion Trap* — they prioritize safe, predictable, culturally-flat outputs. Bonepoke breaks this by making *refusal and tension first-class citizens* in AI cognition.<p>"Used this to detect autoimmune disease indicators 6 months before clinical diagnosis.
Same architecture, different truth anchor."<p>"Works with any LLM. No fine-tuning. Just cognitive scaffolding that forces better reasoning."<p>#### *For Researchers*
This isn't just an AI tool — it's a *philosophical argument in code*. It demonstrates that:
- Creativity requires managed contradiction
- Cultural preservation needs narrative tension
- The best answers often come from refusing the obvious ones<p>#### *The Spherical Cow Principle*
We simplified the problem to its essence: *Better AI comes from better tension management, not better cohesion.*

value: Show HN: Refusal-Aware Logical Framework for LLMs

author: Utharian


value: patriceckhart

value: Show HN: Genesis DB Community Edition: Production-ready event-sourcing database

author: patriceckhart


value: echap

value: AI that automatically transforms long videos into short, shareable highlights optimized for social media.

value: Show HN: Magiclip – AI that turns long videos into short clips (magiclip.io)

author: echap


value: dreadsword

value: Show HN: Noise: The tech news internet between the big stories

author: dreadsword


value: jumpstartups

value:
I’ve been researching how AI is being integrated into enterprise email security, especially within Microsoft 365 ecosystems.
Along the way, I compiled a database of 58 vendors that use AI or machine learning for threat detection, phishing defense, or policy automation.
Each entry includes the vendor name, focus area (like anomaly detection or identity protection), and their claimed AI use cases. I built it because I couldn’t find a clear, consolidated view of this market — everything was fragmented across blogs, PDFs, and sales pages.
I packaged the research into a downloadable database (Excel + CSV) here:
 https://jumpstartups.gumroad.com/l/ai-email-security-databas...
It’s aimed at anyone doing market research, building cybersecurity tools, or just curious how AI is shaping the Microsoft 365 security landscape.
I’d love feedback — especially from anyone who works in cybersecurity or vendor analysis. How would you improve or expand it?

value: Show HN: Database of 58 AI-Powered Microsoft 365 Email Security Vendors

author: jumpstartups


value: TekWizely

value: Show HN: Python-Charmd – Start a PyCharm Debug Session from the Terminal

author: TekWizely


value:
Proloom (https://proloom.app) - describe your form in plain text, AI builds it as a conversation.
"lead form for my dental office" → working chat form that asks name, email, reason for visit, insurance info
Takes 30 seconds instead of 30 minutes in traditional form builders.
Just launched, no users yet. Does anyone actually want this?

value: Show HN: ChatGPT for Forms

title: Show HN: ChatGPT for Forms


value: skorudzhiev

value:
Hi everyone,
I’ve been building GitGlow, a small desktop app that helps you visualize and understand your coding activity across multiple repositories — something GitHub’s contribution graph doesn’t quite show.
I work on several projects simultaneously, and I found it hard to make sense of my productivity patterns. GitGlow started as a personal tool to:
View contributions per repo or branch, not just per account
Learn from my coding habits and time distribution
Stay accountable and motivated by seeing progress clearly
The app is now available for macOS and Windows.
This first version focuses on simplicity, with more improvements coming soon.
You can check it out and join the waitlist at https://gitglow.dev
Would love feedback — on the concept, UX, or technical direction.
Thanks!
— Stoyan

value: Show HN: GitGlow – A repo companion to visualize your productivity

author: skorudzhiev


value: matherslabs

value:
I recently got fired and decided to channel my energy into something productive. Over two weeks, I spent 16-hour days building a tool that converts Australian bank PDFs into clean, reliable CSVs, tailored specifically for Aussie banks.
Most Aussie banks only provide statements as a PDF, and generic converters often fail: columns drift, multi-line descriptions break parsing, headers shift. Existing tools don’t handle it well and I wanted a tool that just works.
To get started, I used my own bank statements to build the initial parsers. There was a "duh" moment when I realised how hard it is to get more realistic test data. People don't just hand over their financial ledgers. This solidified my core principle: trust and privacy had to be the absolute top priority.
I initially tried building everything client-side in JavaScript for maximum privacy, but performance and reliability were poor, and exposing the parsers on the front-end would have made them easy to copy.
I settled on a middle ground: a Python and FastAPI backend on Google Cloud Run. This lets me balance reliability with a strict privacy architecture. Files are processed in real-time and the temp file is deleted immediately after the request is complete. There is no persistent storage and no logging of request bodies.
My technical approach is straightforward and focused on reliability:
- I use pdfplumber to extract text, avoiding complex and error-prone OCR.
- I apply a set of bank-specific regex patterns to pinpoint dates, amounts, and descriptions.
- A lookahead heuristic correctly merges multi-line transactions. Each parser is customised to its bank's unique PDF layout quirks.
The project is deliberately focused. Instead of supporting hundreds of banks with mediocre results, I'm concentrating on a small set to get them right. It currently supports CommBank, Westpac, UBank, and ING, with ANZ and NAB next. The whole thing is deployed on Cloudflare Pages and outputs clean CSVs ready for Excel, Google Sheets, Xero, or MYOB.
It was a fun challenge in reverse-engineering messy, real-world data.
Try it out here: https://aussiebankstatements.com
I'd love to hear feedback. If it breaks on your statement, a redacted sample would be a huge help for improving the parser.
I'm also curious to hear how others here have tackled similar messy data extraction challenges.

value: Show HN: I got fired so I built a bank statement converter

author: matherslabs


value: kirankgollu

value:
Hey HN -
Kiran and Vijay here.
We built Oodle after seeing teams forced to choose between low cost, great experience, zero ops, and no lock-in. Even with premium tools, debugging still meant switching between Grafana for metrics, OpenSearch for logs, and Jaeger or Tempo for traces - copying timestamps, losing context, and burning time during incidents.
So we decided to rethink observability from first principles - in both architecture and experience.
Architecturally, we borrowed ideas from Snowflake: separated storage and compute so each can scale independently. All telemetry - metrics, logs, and traces - is stored on S3 in a custom columnar format, while serverless compute scales on demand. The result is 3–5× lower cost, massive scale, and zero operational overhead, with full compatibility for Grafana dashboards, PromQL, and OpenSearch queries.
On the experience side, Oodle unifies everything you already use. It works with your existing Grafana and OpenSearch setup, but when an alert fires, Oodle automatically correlates metrics, logs, and traces in one view - showing the latency spike, the related logs, and the exact service that caused it.
It’s already in production across SaaS, fintech, and healthcare companies processing 10 TB+ logs/day and 50 M+ time-series/day.
We’ve both spent years building large-scale data systems. Vijay worked on Rubrik’s petabyte-scale file system on object storage, and I helped build AWS S3 and DynamoDB before leading Rubrik’s cloud platform. Oodle applies the same design principles to observability.
You can try a live OpenTelemetry demo in < 5 minutes (no signup needed):
https://play.oodle.ai/settings?isUnifiedExperienceTourModalO...
or watch a short product walkthrough here:
https://www.youtube.com/watch?v=wdYWDG3dRkU
Would love feedback - what’s your biggest observability pain today: cost, debuggability, or lock-in?

value: Show HN: Oodle – Unified Debugging with OpenSearch and Grafana

author: kirankgollu