YHK - yet another hacker news clone

We're getting close! It's just a matter of polishing and polishing and polishing, but I'm really excited about how close we are to launch.

https://codeplusequalsai.com

https://laboratory.love

Last year PlasticList discovered that 86% of food products they tested contain plastic chemicals—including 100% of baby food tested. The EU just lowered their "safe" BPA limit by 20,000x. Meanwhile, the FDA allows levels 100x higher than what Europe considers safe.

This seemed like a solvable problem.

Laboratory.love lets you crowdfund independent testing of specific products you actually buy. Think Consumer Reports meets Kickstarter, but focused on detecting endocrine disruptors in your yogurt, your kid's snacks, whatever you're curious about.

Here's how it works: Find a product (or suggest one), contribute to its testing fund, get detailed lab results when testing completes. If a product doesn't reach its funding goal within 365 days, automatic refund. All results are published openly. Laboratory.love uses the same methodology as PlasticList.org, which found plastic chemicals in everything from prenatal vitamins to ice cream. But instead of researchers choosing what to test, you do.

The bigger picture: Companies respond to market pressure. Transparency creates that pressure. When consumers have data, supply chains get cleaner.

Technical details: Laboratory.love works with ISO 17025-accredited labs, test three samples from different production lots, detect chemicals down to parts per billion. The testing protocol is public.

So far a couple dozen products have received some funding, six products have been fully funded (five product results published, the sixth is at the lab as I write this!)

You can browse products, add your own, or just follow specific items you're curious about: https://laboratory.love

Also, shipping Bedtime Bulb v2 next month. This is a hybrid LED-incandescent design meant for the evening that is the best of both worlds: low blue light, high color quality, perfect compatibility with dimmers, 10x less flicker than incandescent, includes near infrared, low energy use, long lifespan [1].

[0]: https://restfullighting.com/products/restful-atmos-preorder

[1]: https://restfullighting.com/products/bedtime-bulb-v2-preorde...

https://koucai.chat

  const activeAdults = from<User>("users")
    .where((u) => u.age >= 18)
    .where((u) => u.active === true);

It'll go into webpods (https://github.com/webpods-org/webpods), which is like firebase but with hash chains underneath.

I was the feature requestor for Claude Code Hooks - and have been involved in ai governance for quite awhile, this is an idea I'm excited about.

Ping below if you want to early beta test. everything is open source, no signups.

https://github.com/krypdoh/TCKR

Services with stubbed endpoints, UIs with placeholder components, Dockerfiles/Terraform/K8s infra, E2E tests (via declared flows), Github/Gitlab epics/issues/subissues

It's also got github/gitlab webhook integration, so you can do stuff like trigger agents reactively when events occur on a repo, it includes cloudflare tunnel support so you can set up webhooks even in a local dev environment, and the project generator is fully customizable.

There was "choker" back in the day, which I actually never heard about since I wasn't into chess back then. But (1) there was no web version, and (2) it had a specific gameplay that seems too slow for my taste. My version is highly customizable on the setup/rounds/rules, too. From my research, the original was also overrun by bots.

I have experienced knowledge gaps and blind spots that I am attempting to fix. For example most users worry about security of hashed passwords and yet they do not realize that the TOTP (eg Google Authenticator) use symmetric encryption and quite a lot of the authentication providers store the private key in plain text in their database. List goes on...

Behind the scenes, we're doing real time code gen to power the monsters!

Would love feedback!

Along with all of that, still working on a lot of stuff using Jason[4] / AgentSpeak[5]. I created a fork[6] of Jason that is meant to be easier to integrate with Spring Boot, and to take more of a "run headless on a server" approach, which meant taking out references to a Swing based in-process logging/management tool. In place of that, I'm implementing a JMX based management interface, and recently I've started to work on replacing the old Swing app with a JavaFX app that can connect using JMX Remoting.

[1]: https://www.amazon.com/Semantic-Information-Processing-Marvi...

[2]: https://www.amazon.com/Parallel-Distributed-Processing-Vol-F...

[3]: https://www.amazon.com/Principles-Semantic-Networks-Explorat...

[4]: https://github.com/jason-lang/jason

[5]: https://en.wikipedia.org/wiki/AgentSpeak

[6]: https://github.com/mindcrime/jasonfg/

Website: https://colanode.com Repo: https://github.com/colanode/colanode

https://tailstream.io

Launched the initial version a couple of weeks ago and making good progress, trying to share as much of the process as I can on X.

Backend API can be used by any client, but I also built an open source agent in Go that makes setup really easy.

Currently working on a proper log viewer, alerts and visualization improvements.

It started out with bindings for the DOM, Web, and Browser APIs, but as of today I now have custom Web Components support (which is a big deal considering Go's type system quirks).

Tomorrow I'm gonna polish some of the UI components and start refactoring my git-evac [2] repo management tool which is the first app using the gooey framework.

[1] https://github.com/cookiengineer/gooey

[2] https://github.com/cookiengineer/git-evac

https://github.com/ludos1978/markdown-kanban-obsidian

It is a desktop app built with Electron and React. I built to help newlywed couples to quickly sort thousands of wedding photos with a Tinder style swipe UI. It is offline first, fully private, and offers one click export of your selected pictures.

I started building it earlier this year after going through my own wedding photo experience and realizing how overwhelming it can be. I saw my wife dragging and dropping photos from one folder to other and thought there has to be a better way for non-photographer folks.

Right now, I have a working prototype, a landing page live, and I am testing distribution and feedback from early users.

https://picpickr.com

Currently at MVP stage, no domain yet.

This is mostly a nostalgia play--I'm pining for a time when app development was much easier. I'm trying to apply lessons from early Rapid Application Development while still providing a full-featured language.

I confess that I haven't gotten any traction at all, but I find it incredibly useful for my own consulting business, so I'm going to keep on working on it.

Non-Profit to make cross-entity financial crime detection a reality using AI and establishing adequate data standards.

Volunteers welcome (-;

A place to build your corner of the internet.

Minimalistic site builder for portfolio, blog, or just link in bio to showcase your projects and ideas.

here’s mine: https://www.autogram.id/alex

Basically I've realised GraphQL has taken me as far as it can, and I should've gone with REST to start with. That, and after I finish the first milestone (uptime checks + cron job monitors), I'll be able to start building a proper terraform provider, and audit logs.

https://onlineornot.com/, since early 2021.

https://github.com/brainless/nocodo

Self-hosted, multiple models, bring your own keys and subscriptions, unlimited projects, tasks, web based, runs on your cloud server.

I found neverthrow's api to be not very ergonomic so I built my own little version.

https://www.npmjs.com/package/no-exceptions

I've been down a prime numbers rabbit hole. Trying to see the largest prime I can generate in a browser.

We are looking at:

-Objective data: signals from incident management tools (Rootly/PagerDuty), GitHub, and Slack

-Self-reported data: asking the engineers how they feel via short survey

From this, we generate a CBI score (Copenhagen Burnout Inventory). We're still in beta, but we've received positive feedback from our beta testers, especially from manager of large and distributed orgs.

It's fully open-source, you can test it out locally https://github.com/Rootly-AI-Labs/rootly-burnout-detector-we...

Alternatively, we offer a hosted version with mock data, allowing you to play with it. https://www.oncallburnout.com/

If you have any feedback or ideas, shoot them my way :)

Notebook to do it yourself here: https://github.com/dbish/bespoke-books-ai-example

I think there are a lot of really fun projects possible now in the child book creation space, particularly as you build tools that they can use themselves (like adding voice interfaces to building a book or story).

This is outside my 996 job of AI Agent/Assistant infra + ops :)

The community is moving fast though. Now higgsfield allows using arrows and pointers to edit the video but so far, no one is doing a good camera control visually.

It’s a labor of love, but I love it!

I’m currently building a simulation engine that lets you forecast your spending, build scenarios (like taking a year off, getting a cat, move to a new city, etc based on your current spending patterns and assets.

https://myfinancereport.com/

It’s great fun to have a project of one’s own to just toil away on.

https://github.com/blebbit/atproto

https://youtu.be/oYKA85oZc8U?si=DIf09hu8-REw-yHj&t=3758

Examples:

- Policies are frequently subjective. Hard to codify, but LLMs can evaluate them more like a security engineer would. "IAM policies should use least privilege." What is "least" enough? "Admin ports shouldn't be exposed to the Internet." What's an admin port?

- Security engineers are stretched thin. LLMs can watch PRs for potentially risky changes that need closer human review. "PR loosens authz/authn." "PR changes network perimeter configuration."

- Traditional check runs (SAST, IaC, etc.) flood PRs with findings. Security doesn't have time to review them all. Devs tends to ignore them. Frequent false positives. LLMs can draw attention to the important ones. "If the findings are unusual for this repo, require the author to acknowledge the risk before merging."

https://github.com/fraim-dev/fraim

https://www.fraim.dev

https://github.com/scallyw4g/bonsai

I also wrote a metaprogramming language which generates a lot of the editor UI for the engine. It's a bespoke C parser that supports a small subset of C++, which is exposed to the user through a 'scripting-like' language you embed directly in your source files. I wrote it as a replacement for C++ templates and in my completely unbiased opinion it is WAY better.

https://github.com/scallyw4g/poof

My citizenship wait times page (https://allaboutberlin.com/guides/citizenship-wait-times) has also gotten enough feedback to be useful since its release last month. I'd like to make it more useful with better visualisations.

Now I'm working on another iteration of my health insurance calculator (https://allaboutberlin.com/tools/health-insurance-calculator). It's kind of a big deal both because it's a huge financial decision for recent immigrants, and because it funds a big chunk of all the free stuff I'm putting out. This is especially important with ChatGPT and AI summaries halving my traffic. This iteration will recommend health insurance combinations that work for a visa application and for a long-term stay in Germany. It will provide far better explanations.

At the same time, I'm testing a new insurance broker with far shorter response times, so people can directly ask an expert to help them choose. They're reachable via Whatsapp, and that made a huge difference in how people get advice. It worked so well that I want to do the same for other topics. I'm already talking with an immigration lawyer who's interested.

https://apps.apple.com/us/app/dotipa/id6742254881

https://www.demofyapp.com/

I like this Facebook feature which shows you "Today 10 years ago", Immich, does have it in it's UI too and perhaps I will mix in those pictures also to show on TV.

It uses 4k stereoscopic capture and bunch of ML models to match bone position with sub-millimeter precision. The surgeon screws a metal base piece into the bone, and we detect where that is in space. Then, a Stewart Platform adjusts another part that is placed onto the base. The robotic adjustment allows the base to be placed in a ballpark area, with the robotically-adjusted piece oriented in the exact spot where the surgeon needs to cut.

The net result is a robotic system that is many times cheaper than the least expensive incumbent, decreases surgery time significantly, reduces error, and basically "just works" as opposed to requiring a ton of training. We are debuting at a tradeshow in October.

https://playlin.io

to help connect players with daily web games after seeing how hard discovery was.

- https://github.com/skmtc/skmtc

- https://skm.tc

Mostly because I’m working on a personal library management service called Shelvica to solve my own problems[1], and none of those services provided all the information on a book. One might provide the series, the other might provide genres, and yet another might provide a cover with good dimensions, but none provided everything, so I decided to work on something of my own (called Librario).

While Shelvica is the focus, Librario could become its own thing in time, so I don’t mind the sidetracking.

I also plan on having a “ISBN Search” kind of website that feeds from that database as a way to let users search for information about books, which then feeds the service’s database, making it stronger for Shelvica.

I open source everything I make, but I’m still wondering if these will be open sourced or not. I’ll probably go with the EUPL 1.2 license if I do decide on open sourcing them.

[1]: My wife and I have a personal library with around 1800 books, but most applications for management are either focused on ebooks or choke with this many books. Libib is the exception, but I wanted a little more.

I believe the old internet is still alive and well. It's just buried under a mountain of shit.

https://randomdailyurls.com/

Glad I ditched Hugo a few months ago.

- a booking platform for surfing schools - a tool for pelvic physiotherapy practitioners handle appointments and exercise prescriptions

Doing backend and frontend for both, but there is a small team helping with #2. Both come from actual needs of actual businesses.

Tech is pretty standard typescript, react and node.

Would love to be working on these full time.

In Tiled Words you rearrange tiles to solve clues and rebuild a broken crossword.

You can play a demo at https://tiledwords.com - it’s free and web based so it works on whatever device you’ve got.

I’ll be officially launching on October 19th at the Portland Retro Gaming Expo. You can sign up to be notified on launch. Starting then there will be a new puzzle every day!

So far I’ve gotten really positive feedback and have around 100 people signed up to get notified. It’s been a lot of fun to build!

https://meldsecurity.com/

I'm putting a bunch of security tools / data feeds together as a service. The goal is to help teams and individuals run scans/analysis/security project management for "freemium" (certain number of scans/projects for free each month, haven't locked in on how it'll pan out fully $$ wise).

I want to help lower the technical hurdles to running and maintaining security tools for teams and individuals. There are a ton of great open source tools out there, most people either don't know or don't have the time to do a technical deep dive into each. So I'm adding utilities and tools by the day to the platform.

Likewise, there's a built in expert platform for you to get help on your security problems built into the system. (Currently an expert team consisting of [me]). Longer term, I'm working on some AI plugins to help alert on CVEs custom to you, generate automated scans, and some other fun stuff.

https://meldsecurity.com/ycombinator (if you're interested in free credits)

https://news.ycombinator.com/item?id=45400006

I'm super curious if anybody will pick it up and do something useful with it. This was a couple of years of my life and I absolutely loved working on it but having a child put a hard stop to such entertainment for many years. Now, a good 30 years later I finally found the time to resurrect it.

I'm not sure yet if I am going to do more work on it or leave it as it is, it's good enough to give someone new to OS development a running start and a foundation to build on.

I have a video on how it works on https://kavla.dev/

And a live demo here: https://demo.kavla.dev/

I've been working in the data space for five years now. Kavla is something that I personally feel would make my job more fun!

Built with tldraw and duckdb

The idea is that you build a diagram that contains all the details about the problem and people's thoughts on it, and it's organized in such a way that it's easy to just keep refining, down to the smallest detail. So you build this concrete, shared understanding, and move it forward and forward, until hopefully y'all can make some best decision to improve the situation.

There's a lot to do. Currently working on UX to allow hiding intermediate nodes and still have indirect edges drawn. Want to add an LLM integration to generate/update diagrams via natural language, which I think will help a lot with usage barriers to using the app.

Happy to get any feedback :) https://ameliorate.app/ https://github.com/amelioro/ameliorate

This means, instead of the answer to "how do we produce this output data" being "trigger and pray everything upstream is still working", we can answer with "the system was asked to produce this output data partition and its dependencies were automatically built for it". My hope is that this allows the interface with the system to instead be continuously telling it what partitions we want to exist, and letting it figure out the rest, instead of the byzantine DAGs that get built in airflow/etc.

This comes out of a big feeling that even more recent orchestrators like Prefect, Dagster, etc are still solving the wrong problem, and not internalizing the right complexity.

If you can't afford early access, please email me and I'll grant you a free copy: I need all the feedback I can get!

[0] https://terminal.click

Unsure what the plan is going forward with it, apart from adding more venues and more countries. As long as it's fun for me I'll just keep adding things.

Next addition will be to add health inspection data from countries that have that in open datasets or APIs, so if anyone know of that I'd be appreciative of hints (know of UK, Norway and might have found for France).

Upload receipt photos, assign who got what, and easily calculate splits.

I’ve found these services charge way too much per GB of memory (10x more than IaaS providers), but more importantly, offer terrible flexibility. You can’t schedule multiple apps on the same instance, and there aren’t many instance size options.

Canine also supports deployments of any helm package (postgres, airbyte, dagster, etc) via helm charts.

https://github.com/czhu12/canine https://canine.sh

https://lmao.center/ilotoki

Every aspect of the games are narrated in real time so you know what's going on. I'm still in the prototype stage and I've seen some pretty hilarious interactions already.

The Bluesky ecosystem is a really great platform to build social media on and with Pinterest being overtaken by AI content I figured I'd give it a shot. There is definitely not as much content there, but it is of much higher quality and the culture of providing alt text on images really makes search work rather well.

1 - https://scrapboard.org

2 - https://bsky.app/profile/scrapboard.org

On the weekend built a lattice-filter test jig with the LiteVNA64, so sorting though the pile of crystals is less time intensive.

Other hobbies maybe 3 other people would find amusing. =3

I have seen the 'you are absolutely right...' response at least 1000 times already.

https://github.com/smoqadam/musrv

Why? >

LinkedIn isn't for creatives. Actor's Access is dated and charges a ton for basic extras Squarespace/wix is fine but everyone in 'the biz' has one and nobody wants to maintain it. Plus they're all silo'd.

Check out my site if you wanna. You get to host your own headshots, resume, and reels. You can upload your screenplay there and hear it read outloud. You can put up your cinematic scores and make a place to send people to hear your music.

https://cinesignal.com

Looking for users who wanna test the system out. Give me a shout and I'll throw you some credits if you wanna hear your screenplay read outloud.

Thinking about play testing at scale is a new thing for me. I've been getting into visualization techniques like using 3d textures to build voxel heat maps in-editor. We've managed to accumulate quite a bit of play testing telemetry already. The power of aggregated statistics in the editor views is absolutely mind-blowing to me. For level designers it's like having proper omniscience. Being able to see things like thousands of samples (manifesting as a bright red voxel) that wound up tripping over the same misplaced geometry is like cheating.

Red-green-refactor is tedious for humans but perfect for AI. And the test names & code make great documentation of every micro decision, running in milliseconds to prevent regressions.

The software itself helps people perform construction approvals.

Old way: dozens of documents and versions sent back and forth over email. Many fiddly details that must be checked - to streamline the process we'll use AI to provide verdicts that help humans make decisions.

I plan to create content & teach what I've learned.

https://approviq.com

www.kpbj.fm

To organize them, I'm writing a Python Qt application with Claude Code. It started off as vibe coding, but I'm now developing it using processes very similar to those I would use when managing software teams. I've picked up a lot of good tips about that here on HN. I've got Whisper, and fallback online services, transcribing the audio and summarizing it and adding tags. After much UI experimentation, I've landed on something that looks not unlike an email client, with tags in the left pane, a center pane which lists transcriptions and notes about each audio file, and a right pane with more detailed information about the selected audio file.

Next step is to serve it all as a model context protocol server - I need to pick an agent.

https://affectablesleep.com

Our patent-pending neurostimulation builds on over a decade of research in slow-wave enhancement, and more than 50+ published peer-reviewed papers.

Today we're building our last 3D printed unit. In October we start our first tooling run.

Currently trying to predict student absenteeism in the future based on historical indicators with synthetic data using basic ML modeling and then using LLMs to generate helpful guidance for relevant parties. Basically letting parents know there's concern and citing leading indicators.

Not sure what I'll do next, but hoping to come up with a few other ideas to put my mind at ease. It's fun having some actual motivation to keep up with the current hype instead of just being a consumer, though!

Key problems we're solving:

- Everyone wants to be doing meaningful, fun work that feels like their "life's work". Few feel like they are.

- In recruiting, the AI spam problem is real and only getting worse, essentially killing the cold application pipeline. You need a referral.

- Optimizing your career feels like annoying politicking for a lot of the most talented folks who just want to focus on building cool stuff. But, as an employee, if you don't test the market (e.g. take a recruiter conversation) from time to time, your comp can really stagnate.

https://www.kyoubenkyou.com/

In short, it's a few things:

- JA->EN dictionary

- hiragana / katakana / time reading / number reading quizzers

- learn kanji with FSRS, anki-style

- vocab quizzer

- the coolest feature (imo) is a "reader": upload Japanese texts (light novels, children's books, etc), then translate them to your native language to practice your reading comprehension. Select text anywhere on the page (with your cursor) to instantly do a dictionary lookup. A LLM evaluates your translation accuracy (0..100%) and suggests other possible interpretations.

It's all elixir+liveview+postgres+pgroonga (though there are times when I would like to have SolidJS).

I've been considering open-sourcing it due to lack of commercial success, but might try an ad-based approach first.

https://www.inclusivecolors.com/

It gives you precise control over every shade/tint (no AI or auto generation!) so you can incorporate your own brand colors, and helps you build palettes that have simple to follow color contrast guarantees by design e.g. all grade 600 colors have 4.5:1 WCAG contrast (for body text) against all grade 50 colors, such as red-600 vs gray-50, or green-600 vs gray-50. There's export options for plain CSS, Tailwind, Figma, and Adobe.

I'm really open to feedback on what problems and needs people have for creating accessible designs!

I recently published https://github.com/hxtk/sqlt for SQL query generation with Go templates.

I’m working on https://github.com/hxtk/aip as a collection of libraries giving safe default choices to implement Google’s API improvement proposals in ConnectRPC services. It borrows (with attribution per the license) an unexported implementation of AUP-160 filters from the LuCI project, and I intend to expand it to support data sources other than SQL databases and page tokens, and it also exports an implementation of AIP-161 field masks (which have different semantics compared to standard field masks) and middleware to help with using them for AIP-157 read filtering. I intend to export more middleware that I use frequently, but I don’t know if it’ll live in this module or its own yet.

I feel like I am locally constantly bouncing between different agents for different tasks and really wanted to be able to do the same in a remote environment.

https://quietui.org/

It prioritizes accessibility, longevity, performance, and simplicity.

With the autoloader, one script tag loads components dynamically without downloading the entire library. (npm also available.)

Theming uses color-mix() and OKLAB to create uniform color palettes from a single CSS property. Adaptive palettes are used for dark mode.

All form controls are form-associated via ElementInternals and work with native validation APIs (required, pattern, etc.).

Dialogs, popovers, tooltips, etc. use Popover API for top-layer access without having to portal or hoist.

Some of the more fun components include: Joystick, Stamp, Mesh Gradient, Flip Card, Random Content, Intersection Observer, Typewriter, Lorem Ipsum, Slide Activator

The library is free for personal, educational, non-profit use. Commercial use requires a license.

I've been playing guitar for a little under 6 years and ran into the common problem among many intermediate guitarists fall into, which is stagnating into a plateau at a certain BPM.

The most effective solution I've found is to take the top speed hit playing a chunk of a lick and simply increase it 20-50 BPM past that limit, attempting one's best to stay in tempo. Regardless of how sloppy it sounds. Then roughly halve that increased addition of BPM, it will become relatively easier to play. For example, if you are stuck at 120 BPM, upping it to 150 BPM with sloppy attempts, then dropping it back down to 130-140 BPM.

I've gone cleanly from alternate picked 140 BPM triplets to 220 BPM triplets in two months after being stuck at 140 BPM for over a year with this method. Sometimes even hitting 280 BPM triplets when I have the focus and time for it.

Even then, I want a more consistent, and variable way of customizing a practice session using a metronome from a hobbyist perspective without using a DAW. With a simpler interface for doing so. As well as encourage with said method above for other guitarists in the pursuit of speed.

Diplomium helps educators and event organizers create and deliver authenticated certificates at scale. Instead of manually designing and emailing PDFs, you upload a simple Excel, pick a template, and the system generates + sends personalized certificates automatically—each with a unique QR code for instant validation.

The bigger picture: Certificates are often the only tangible outcome of a learning experience. By making them verifiable, permanent, and easy to distribute, organizations save admin time while learners get a trustworthy credential.

Status: Running for 2 years, used by schools and training centers in Latin America. Now building AI-powered features for design editing and data extraction from PDFs.

First chapter already out. https://aibodh.com/posts/bevy-rust-game-development-chapter-...

Right now I’m experimenting with a simple bookmarklet trigger instead of a browser extension. Curious: how do HN folks feel about bookmarklets in 2025, still viable, or do you prefer extensions?

Spanara - A word game inspired by the "license plate game" my wife taught me while we lived in Finland. License plates in Finland always start with 3 letters, so out on our walks we'd try to come up with a word quickly, and got more kudos for "good" words. This was a first attempt at a personal project using AI.

I am currently working on a new mode that is more like what played walking around: a few rounds in rapid fire, very little time to think before the next round.

While building that, I basically wrote a modern version of Tampermonkey with its own marketplace built in. So you can vibe code any userscript and publish it to the marketplace all within the extension.

The automation stuff is still the core value-prop, but this is a fun bonus feature while I work on solidifying the automation features.

I'm writing a HN post for it. Excited to show everyone in a couple weeks here.

Typing is an extremely underrated skill and especially in the age of LLMs, it is the bottle neck in a lot of cases.

I’ve never been fond of existing typing apps; excessive ads, typing random words, etc so I built my own.

You can practice typing code, use your own text, etc

We have a paid plan for features where you can type natural text that targets your weak points (via SmartPractice) and many others. Other than that, it’s both free to use (and ad-free)

I can't take much credit for anything really, all of the meat came from Tim Sweeney himself: https://www.flipcode.com/archives/Texturing_As_In_Unreal.sht...

I miss the golden days of flipcode.

It's a personal knowledge system. It's a zettelkasten with an LLM substrate. It uses LLMs to build a model of the theses, arguments and facts used in cards, and uses these to both summarize the information on the card and to automatically link cards together based on shared concepts.

I was literally thinking about quitting in August. My motivation is now at an all-time high - some users have done >8k pushups :)

As always, the key has been the marketing (10M views on Instagram). But we have to improve the product to make people love it even more. So the roadmap is more full than ever.

[1] https://pushscroll.com

https://blueapex.pro

I think it'd be useful for people exploring new cities to view maps created by locals for recommendations.

ingesting/parsing gpx layers into duckdb using python to extract tags and load api data. using minio right now but ultimately want to push to cloudflare free tools or vercel.

So far, we've built the video generation and dream journaling features. The app is live on TestFlight, and we're preparing a major update soon that includes a new better UI, and dream questionnaire to help with pattern recognition and dream mapping.

Would love to hear thoughts, feedback, or connect with others working on similar intersections of tech and the mind! If you're interested in trying it out, you can find the TestFlight link on our website: https://visirya.com

https://github.com/stravu/crystal

It supports Claude Code and Codex, but has you constantly working on multiple features in Git worktrees. This way you are always able to stay busy while waiting on your agents.

It has built in tools for review, such as a diff viewer, and a quick button to run your application in different worktrees for testing. It has completely transformed the way I work.

Most design inspiration sites lean heavily on curated mockups (Dribbble) or award-winning showcases (Awwwards, Mobbin). That makes them polished, but they don’t reflect what most production sites actually look like. Font of Web takes a different approach: it sources directly from live websites, and the community can clip specific elements instead of entire pages. That means you can browse navbars, pricing cards, dashboards, etc., not just full screenshots.

Each clip is enriched with metadata (fonts, color palettes, original domain). Search works across that metadata, natural language queries (“minimalist fintech dashboard”), and even visual similarity — so you can find results either by text or by image.

There’s also a Chrome extension to snip and save from any site.

I’d like to hear from designers and frontend engineers: is this useful in your workflow? Anything obviously missing?

Since a few months back I am working on a side project to give a snapshot of the regional and global species and natural ecosystems.

I use manual (me) and automated tools (web and literature search tools, llms, visualizers ...) to search, extract, organize and visualize ecosystem literature and data.

A regional example of mountain gorilla's of Rwanda: https://www.earthmetainsights.com/emi-cards-gorillas-of-rwan...

A global example of Elephants across the world: https://www.earthmetainsights.com/emi-cards-state-of-elephan...

If there are some species that are you would like to see a snapshot of, and the region/location let me know and i will try to get a similar visualization. DM or as reply to the chat. Share the species name (common or scientific) and location (can be a city, town, region, province, country).

It is a work 8n progress, but I would be very happy to recieve feedback.

https://ivyreader.com/collections

All out of pocket. No monetisation. No analytics

https://consentless.joeldare.com/

https://github.com/codazoda/minimark

[1] https://www.manning.com/books/machine-learning-for-drug-disc...

Inspired by Forrest Mims III, Don Lancaster and the "75 in 1" style electronic project kits my mom got for me for Christmas when I was a kid.

I hope to sell them and then probably never recoup my investment.

[1] https://imgur.com/8pkHiSm

(I'll leave it as an exercise for someone clever to figure out what circuit is being depicted in the photo.)

Cordyceps: A port of Playwight that doesn't use CDP or Chrome DevTools Protocol either over websockets or chrome.debugger. Instead it uses pure DOM and Chrome Extension APIs. It includes a port of both Stagehand and Browser Use that run purely inside the Chrome Extension. [0]

Doomberg Terminal: A Chrome Extension that performs algorithmic trading using Robinhood's web interface and market data. [1]

crx-mcp-over-cdp: This is a proof of concept demonstrating how to run a Model Context Protocol (MCP) server inside a Chrome Extension using Chrome DevTools Protocol (CDP) - no external server required. (Sort of, I left out the actual MCP library implementation. Ran out of time.) [2]

[0] https://github.com/adam-s/cordyceps

[1] https://github.com/adam-s/doomberg-terminal

[2] https://github.com/adam-s/crx-mcp-over-cdp

I wrote a blog post about my initial findings recently: https://jms55.github.io/posts/2025-09-20-solari-bevy-0-17

https://go-mighty.vercel.app/

(Will probably register a proper domain name close to release)

Historically, Astro hasn't had an API like renderToString for React/Vue/etc. that takes a component and renders it on the server. That changed with the release of the Container API last year: https://docs.astro.build/en/reference/container-reference/

But there are still a lot of rough edges:

- Importing components is a hassle (you have to go dig through the Astro manifest or create a TS file that exports all your components)

- No Vite integration (so no local dev support, or hot reload)

- No styling support (this is probably the biggest one)

Mighty will provide dev + styling support and a simple way to import your Astro components, with adapters for Hono and Laravel when first releasing. For Hono, it should be as simple as writing a few lines of code:

https://go-mighty.vercel.app/guides/backend-adapters/hono/#r...

Still WIP, but I hope to have something out by the end of the year! Let me know what you think.

https://go-mighty.vercel.app/

(And yes, I wrote the docs before the code! It helps me structure my API design far better, even if not perfectly)

https://github.com/codazoda/llm-jail

I don’t know if this is really necessary, but I created it after doing an in-house CTF challenge, with no LLM rules, and I was giving several LLM CLI’s a lot of leeway and iterating very quickly.

Social media network where users post microgames!

1. Fluxmail - https://fluxmail.ai

Fluxmail is an AI-powered email app that helps you get done with email faster. I think there's a significant opportunity for AI to change the way we use email, and I'm experimenting with ways to improve the status quo. I'd love to hear what features you'd like to see in such an app!

2. ExploreJobs.ai - https://explorejobs.ai

This is a job board for AI jobs and companies. The job market in AI is pretty hot right now, and there are a lot of cool AI companies out there. I'm hoping to connect job seekers with fast-growing AI companies.

https://shodoku.app/

https://github.com/runarberg/shodoku

My theory of learning is that you learn the characters better if you learn how to read and write them at the same time. And flash cards are better by giving you as much information as possible about the character.

This is fundamentally different from e.g. WaniKani which only teaches you how to read the character and relies on pre-made mnemonics (plus SRS) for easier retention, and from Anki which (normally) has very minimal flash cards, showing only small bits of information per card. When you have the whole dictionary on each card it gives you the opportunity to create the easiest connection with what you already know. This may be some made up story about the components (radicals) in the kanji (like WaniKani does) a word you already know, other kanji sharing the components, etc. The more connections you make the easier it is to learn them.

One of the features I personally use extensively is the ability to bookmark words containing the kanji, which will then pop up at the top of the words section in a later review. If I remember the meaning and the reading of the words I have bookmarked for this character during a reading review, I consider mark card as good. If I remember none of them I mark it “again”.

https://reprobate.site/

I actually did a SHOW HN exactly 3 months ago and received lots of invaluable critique regarding how dense, overwhelming and unreadable the docs and repo README were. I've actually spent a lot of time trying to improve the quality of the docs and README since then. I'd love to receive any feedback, negative included, regarding the current overall quality of the docs and README from whoever is interest in that space.

I’m looking for beta testers—happy to share early access if you’re interested! If you are please message me.

- No sign-up, works entirely in-browser

- Live PDF preview + instant download

- VAT support (EU-friendly)

- Shareable invoice links

- Multi-language (10+) & multi-currency

- Multiple templates (incl. Stripe-style)

- Mobile-friendly

GitHub: https://github.com/VladSez/easy-invoice-pdf

Would love feedback, contributions, or ideas for other templates/features!

GCAT: https://planet4589.org/space/gcat/

Dashboard example: https://trilogydata.dev/trilogy-studio-core/#screen=dashboar...

Uses SwiftUI for the UI, and Zig does most of the heavy lifting on the backend. It's inspired by ghostty which uses a similar setup[1].

Right now it only works for Mac, but I'll be porting to iOS as soon as I get the markdown renderer polished. It's not available to the public yet, but I'm using it as my daily driver and hope to release it later this year. I've open sourced it so you can see the source code here[2].

1. https://ghostty.org/

2. https://github.com/emmettmcdow/nana

https://gitlab.com/ahoneybun/nyxi-installer

Document (DOCX/PPTX/XLSX etc.) translator that preserves your file's layout.

https://productionapps.ai/

I'm sick and tired of audiophile level bs floating around online forums and I want to create a simple tool for people to fiddle around with different settings to see what really impacts their speed while cycling.

As usual - no plans for monetization whatsoever. Nothing fancy either, just an elaborated weekend project.

If you like the idea and want to help with graphic design and or html just let me know. :)

https://github.com/David-OConnor/daedalus/

Also, still working on https://drumpatterns.onether.com :)

The app is nearly completed, and Grok (preview in Copilot, currently free) wrote most of the CRUD pages with Entity Framework. Of course, it does get things wrong, and I use Claude 4 to fix the issues. (i'm a C# dev, I review code generated by Grok sometimes.)

https://opaledx.com

- rich markdown editor (via mdxeditor.dev) and source (codemirror6)

- uses indexeddb and optionally opfs (select a directory on your local hd)

- some service worker hacks to do seamless image processing (jpg/png -> webp), storage and retrieval

- document snapshot history, thumbnail preview with iframe and snapdom: html->img sorcery

- live previews and compilations

- loads very quickly, navigation and cold starts, images make heavy use of the Cache api

- use in-browser git (thanks isomorphic-git) for version control; optionally sync with github via cors proxy (host your own if you want)

- best of all completely free to use. 99.5% finished MIT github repo dropping soon ;)

It augments your existing muscle memory: a quick tap of a shortcut switches apps like normal, but holding it opens a powerful interface with features like:

Unified Search: Instantly find any window, app, or browser tab.

Scopes: Save and restore entire window layouts for different projects (perfect for after you unplug a monitor).

Placement Modes: Snap windows to screen halves as you switch to them.

The goal is to make the OS feel as fast as my other tools. I'm always looking for feedback on how to make window management less frustrating!

There are some AI spreadsheet products out there mostly as plugins along with MS Copilot. However my experience with them showed that they are bad at understanding spreadsheets.

The reason is that sheets are 2D data models. Because LLMs are trained on 1D data models (simply text), translation of 2D data models to formats an LLM can consume is a big context engineering task.

I read and implemented some of the algos mentioned in SpreadsheetLLM paper released by Microsoft. Ironic, isn't it?

Got it to a nice working state. Give it a go - if you need more tokens, let me know!

It's not a from-scratch effort, quite the contrary: I'm trying to tie in existing music standards (MIDI, MusicXML, SMuFL, MEI, etc.) and ensure that FOSS systems (MuseScore, Verovio, smaller components) implement enough of those standards to support music-i18n.

Sometimes, this also includes extending the standards themselves when they are not fully capable of representing some non-mainstream musical aspect. For example, MusicXML lacks the ability of representing multiple accidentals per note (whereas MEI does), which is a must for microtonality.

I started down this path around 2018, as a music player who got interested in arranging Arabic songs in a "Real Book" style. It opened a giant rabbit hole that I'm still far from having fully explored.

Now and then, I collaborate with other devs who are interested in adjacent topics. I would love to hear from some of you here!

As an entry point, I recommend checking out the "progress report" I wrote last October: https://blog.karimratib.me/2024/10/01/music-grimoire-progres... - I'm currently drafting this year's update. My main demo is at https://blog.karimratib.me/demos/musicxml/

https://simpleobservability.com

I built it because I needed two things:

- A super easy-to-install monitoring tool that doesn’t require bash scripts or config files

- A mobile-friendly, UX-first interface where I can check everything from my phone

It’s now pretty feature complete. I can see a full picture of all the servers and VPS I run straight from my phone.

Setup is one command, no config files, and everything else happens in the UI. There’s a catalog of predefined alert rules, and creating new ones is easier than anything else I’ve used.

There’s a free tier if anyone wants to try it!

Recently, I have released a simple IDE (called the Bench) to try Circuitscript online: https://bench.circuitscript.net/

The next steps are to create more schematics with Circuitscript as examples to test the limitations of the language and to generate PCB designs with KiCAD. The Circuitscript tool (currently only the desktop cli tool) is able to generate KiCAD netlists and this can be imported into PCBnew.

The motivation for creating Circuitscript is to describe schematics in terms of code rather than graphical UIs after using different CAD packages extensively (Allegro, Altium, KiCAD) in the past. I wanted to spend more time thinking about the schematic design itself rather than fiddling around with GUIs.

The main language goals are to be easy to write and reason, generated graphical schematics should be displayed according to how the designer wishes so (because this is also part of the design process) and to encourage code reuse.

Please check it out and I look forward to your feedback, especially from electronics designers/hobbyists. Thanks!

https://afterglow-game.com/

Yesterday I proved the infinitude of primes, which I was pretty happy with. https://www.philipzucker.com/knuckle_primes/ A trivial theorem in the scheme of things, but one for which z3 certainly can't do it on it's own.

As it is fashionable these days, it can create checklists with AI ("Fun things to do in Pittsburg"), you can create checklists from templates (some stuff you do every day), etc.

I also have an MCP server that allows you to plug it into your favorite LLM.

I've used Monica HQ to keep track of this but thought I could tackle differently using AI. With AI you could ask questions like "who's everybody on my aunt's side? Like cousins and their family" and get a good answer.

Afaik other "relationship managers" out there are professionally oriented, for sales people. A lot of them talk about LinkedIn integration, for example.

Take a look at http://emilia-workers-website.inerte.workers.dev/ and if you're interested in Alpha testing, send me an email at inerte@gmail.com - I setup a Discord last week so early adopters can chat with me about.

It looks inside each file to see what it’s about, then moves it to the right folder for you.

Everything happens on your Mac, so nothing leaves your computer. No clouds, no servers.

It already works with PDFs, text, Markdown, and many other file types. Next I’m adding ePub, and later Microsoft Office and iWork support.

If you have messy folders anywhere on your Mac, Fallinorg can help.

We took a great amount of learning from tools like Cline, Roo.. After spending some time on their tech as active users/devs, we decided to build multi from scratch with drastically different take on core features, tech stack, ux/devex..

If you are an active user of similar tools, and/or want to try multi.. We want to hear from you.

-- edit: I am one of the core contributors to multi. And we are in the process of open sourcing it.

Very early into this - would love feedback!

It's largely based on platform-izing the extremely popular Timeleft app that simply matches 6 random people for dinner. With onthe.town, anyone can create a Timeleft-like app around any concept they're interested in. Some clubs people have created include a golf club (get matched with 3 other people to play golf with), a vinyl record sharing club, a lunch club for biotech networking, and a club to meet other parents for dinner.

IME it results in much less context clutter from your test output.

https://github.com/zk/3pio

Launched on Reddit last week: https://www.reddit.com/r/Optionswheel/comments/1nlelbp/comme...

If you guys trade options (selling CSP and CC), I would love to hear your feedback.

https://gitlab.com/rusto64/core

No visual or sound yet; still working on making tools to debug the execution.

Live demo of the debugger : https://n64.watier.ca/

I have several friends in this industry and their tooling is either expensive, not localized for their market or straight away bad (I've seen terrible dataloss).

I got some inspiration from linear and am building it on top of ruby on rails with CRDTs.

https://bloomberry.com

1. COCKTAIL-DKG - A distributed key generation protocol for FROST, based on ChillDKG (but generalized to more elliptic curve groups) -- https://github.com/C2SP/C2SP/issues/159

2. FREEON (Threshold signing tool for open source development teams) -- https://github.com/soatok/freeon

3. A reference implementation for the specification I wrote last year for federated Key Transparency, so that the Fediverse can build end-to-end encryption (E2EE) with stronger, less-centralized notion of trust than TOFU -- https://github.com/fedi-e2ee/public-key-directory-specificat...

I wrote a blog post about a lot of this work (and my other side projects): https://soatok.blog/2025/08/27/its-a-cold-day-in-developer-h...

And for the overall ActivityPub E2EE work: https://soatok.blog/category/technology/open-source/fedivers...

https://thumbnail.ai/

You just upload a picture and pick a design type and it generates a thumbnail for you. Got good feedback last time I posted, steadily and slowly growing now.

Initially I have been looking at Mastodon and Bluesky since they have sane APIs.

The plan is to make it so that you can sync your data folder either manually (e.g. dropbox, or sneakernet if you want) or a via a basic cheap data plan.

Website: https://jacobin.org

GitHub: https://github.com/platypusguy/jacobin

- Ignore AI voiced books

- Show me unread books in series that I have in my library

- Experimenting with better search. I have experience with building semantic search systems and have been highly disappointed with Audible's extremely sub-par search capabilities. I want results that are actually based on books, authors, and narrators that I have already purchased, read, or listened to.

- Get automatic notifications when new books from authors and narrators that I subscribe to become available.

There's at least a few more gripes I want to address, but these are the high priority ones that come to mind right now.

Another project of mine is to play music from my audio CDs by myself. I built a simple Rust library to read TOC and raw PCM data from a CD drive -- https://github.com/Bloomca/rust-cd-da-reader (works on Windows, macOS and Linux), and a ripper -- https://github.com/Bloomca/audio-cd-ripper, which rips all tracks and encodes it as FLAC and fetches metadata from MusicBrainz.

The next step is to play it. I looked into using cpal (https://github.com/RustAudio/cpal), but I feel like using low-level audio API for each platform is a better approach for learning.

https://sweetshop.app

It's a digital comic book store. Letterboxd with a buy button. It's really fun. We've got a lot of great publishers signed, and a great team. It's such a thrill to work in a space where people work their ass off to create art, in spite of the fact that the rewards are minimal. Our job, we feel, is to make them more money to make more art.

Need to add gas planning next!

https://dreamstateai.replit.app/

Traditional Knowledge: Constrained to Ibn Seerin's classical teachings — trusted by Muslims for over 1,000 years AI-Powered Analysis: Unlock the meaning of your dream with 4,300 dream symbols from the Dictionary of Dreams.

Share your dream confidentially, answer a few context questions, and receive your authentic Islamic interpretation in under a minute.

This is an MVP which I started <4 weeks ago. Currently validating Desirability, Feasibility, and Viability.

It started as a solution to LLM front ends having terrible native branching features. But slowly I realize most of our data will be going through LLM's so Yggdrasil is evolving into a platform which consumes all your LLM queries, while keeping it easy to query and reference.

And now I have begun to realize how detrimental LLM assisted coding can be to someone who starts depending on it too much, so Yggdrasil is a bet in the other direction as compared to mainstream. Instead of agents/AI doing everything I believe human + ai assistance will win in the end.

Yggdrasil has a simple agent called Valkyrie, so they have their place, but that I believe should be the last step, after the developer has discussed and planned thoroughly through our tree interface, Heimdall.

And if someone replaces the dev, they can browse their conversations with the LLM, observe their mind map, what questions they asked, what extra things they considered (branches), the whole thought process easily navigable and visible.

Personally after using Yggdrasil, I feel quite confident in using the LLM, as I can ask all the silly questions I want, without worrying about context pollution. It aligns really well with the natural exploratory tangential thoughts we have when trying to find solutions or learn something.

There are a lot of things that I still want to polish, but it's in a usable state already, and I'm very happy with it.

If someone takes a look and has any suggestions, feedback, or ideas, they are all welcome.

Also, any suggestions for blogs that could be added as sources is appreciated.

Metaballs: Spatial, which is a really fun interactive sculpting app. Brand new app. Fast-follow update this week adds USDZ and STL export! https://apps.apple.com/us/app/metaballs/id6748781900

Vibescape: an immersive meditation app. This one is currently featured at the top of the App Store, yay! Launched as a day one app on Vision Pro, new update has what I think is the best immersive environment I've made yet that comes alive with music: https://apps.apple.com/us/app/vibescape/id6476827678

I'm also working on the next episode of Ice Moon — a YouTube series I'm doing on how to build immersive environments for Apple Vision Pro: https://youtube.com/playlist?list=PLHA_sJmXyiktWkqLnHEUj1k5h...

https://localxai.com/demo

A mobile app to track tasks, events and any info about anything you care about: your car, home, tools, workshop, appliances, pets, lab equipment... anything really.

Lets you organize "resources" in a hierarchy (like "folders"). You can then define tasks, add pictures, geolocation, contacts, notes, events, etc to them. Recently added the feature to "share" resources with others.

Google Play: https://play.google.com/store/apps/details?id=com.code54.qui... App Store: https://apps.apple.com/us/app/obsetico/id6749025870

It's so generic that it's hard to describe :-) I need a better elevator pitch.

https://whytorch.org/

A great example of how it works is http://whytorch.org/torch.amax/

Clicking items in the tensors explains where they came from and where they are used in the output. The input tensors can be modified too.

It's a one-man side project that's been half building the site framework, and half re-implementing pytorch functions in javascript. Plenty more functions to go, but hopefully people can already find it useful. I'm planning on doing a Show HN once I've added ~10 more functions.

Posting this from a throwaway account because my main account is locked due to `noprocrast`!

https://github.com/NoMoreNicksLeft/repulp

I still need to put together a build system to actually zip this up into an epub file...

The space is moving so fast, so I had to note down my thoughts e.g. https://blog.toolkami.com/openai-codex-tools/and figure out what's next.

I'm also generally disappointed by the lack of testing that's performed on feature-flag definitions. So I'd like to have a test runner capable of asserting your feature flag's rules matches your intent.

Also working on DailySelfTrack ( https://dailyselftrack.com/ ), an app to track what matters to you in a way that you find relevant. So it is a mix of habit tracker, health log and journal. Like a spreadhsheet app, but with much better UX. And like a habit/health app, but with much greater customization.

I want this to be a tool highly useful for people who have complex health issues, are working towards ambitious goals, or just want to regularly reflect on their day.

I'm building it since I couldn't find a satisfying solution anywhere. It's local first and does not force you into a subscription, or tries to exploit you with any other dark patterns

https://clampwind.dev

No likes, no feeds, no noise... just beautiful albums and good energy.

Focus is on memory moments, not social media. Early users are using it for family trips, kids, and quiet reflections.

Would love feedback: https://aurajoei.com

Current Challenges:

Technical: It's difficult to consistently parse text from various document formats. The I also wants to expand to more platforms but I know I need to focus on marketing.

Non-technical: The product has seen some success with minimal marketing, but I keep getting distracted by spending too much time on technical work. I know I need to do more for marketing but I keep going to my safe space (my IDE).

I believe in the product but it keeps reminding me how difficult is to get somethig to a polished, finished state for all users. 90% of the project takes 90% of the time and the other 10% takes another 90% of the time.

Appreciate any feedback.

https://desktop.with.audio

This is a solo startup that I've been working on for 2 years now. It's a labor of love and I'm very lucky and thankful that it's big enough to surprisingly pay all of our bills. Still constantly feeling FOMO over all of my startup buddies working with AI and LLMs while I plug away at old maps and GIS .

It gets ~80K MAUs and just slowly and consistently is growing organically through word of mouth through history focused communities. I'm currently playing with expanding the coverage internationally as I still only support the US which is a wickedly fun project.

I want one place to manage ALL notification settings. So if I want to be notified of Slack messages that contain the word “cat”, I can do that.

I am also looking to add summarization and tagging using a local SLM. Trying to find a method that can run on older hardware.

https://blog.webb.page/2025-09-28-ikigai.txt

I did figure out something I've long wondered about recently. Y'know how you can see previews of videos in Messages? I got it working! Here's an example video: https://nickel.video/6NI3n_IlIlII

My inspiration for Nickel was 1) missing Vine and 2) not wanting to use YouTube to share my gaming clips.

It's literally just me in the garage right now banging out prototypes, talking to MSPs, and probing networks/WiFi/OS to make this tool.

The hope is that companies care whether employees are productive when remote/hybrid/on-the-road, or at least are sick of trying to triage first line helpdesk tickets about home network issues and Zoom glitches.

Demo: https://x.com/stopachka/status/1972122239123521614

Github: https://github.com/stopachka/pg-essays

I just made a Cuckoo Clock productivity timer. A 3D borderless widget that appears at set intervals. Using Tauri and threejs. https://cuckootimer.com/

And a conversation starter card game on web.

https://convo.cards/

https://raizensoft.com/tutorials/

Currently it mainly focuses on libGDX which is my most favorite framework. I prefer code-centric approach because that's how game development should be in my opinion.

Most of the tutorials are just pure coding with algorithms explanations. My goal is to build one of the most resourceful website for libGDX because it's quite underserved at the moment.

In the future I may expand to other code-centric frameworks and more general game development topics, let's see how it go.

https://ovelle.bio

https://www.youtube.com/watch?v=xEy34cuOPaY

[1] https://folk.computer/

I made an install script for Arch Linux that sets up the bare essentials for a new install. You can fork it and edit it to your own liking. https://github.com/QCgeneral29/AIP

I've been working on a map that shows which neighborhoods in a city are nice/not nice with a short description.

Whenever I visit a new city, just looking at Google Maps is pretty meaningless - it's just a bunch of gray land and streets. I end up looking up Reddit posts for where to go, searching for crime maps, trying to find annotated maps, etc. to get a better idea of where to visit in a city (or even live, like when I had moved to Austin). AI generated scoring and descriptions, while imperfect, have already helped me when visiting SF recently. Early stage, so please help with submitting corrections, if you'd like!

It started out as a Spotify oriented project but due to their recent API changes[2] I ended up focusing more on a Last FM integration. This wasn't that bad as their API provides more details such as play count per song. I've also added an Apple Music integration.

I posted about it[3] on Last FM's subreddit and I was pleasantly surprised to see that a lot of people shared their labels on the comments and seemed to like it.

I'm currently working on language detection, I think it'd be cool to get a language breakdown of the songs you listen to and for that to be part of the displayed items within the label. Something along the lines of EN- 80%, ES- 15%, FR - 5%

I've also tried getting Adsense on the website but I keep getting denied on "Low Content Value" grounds. I tried some alternatives but the quality of their ads was ridiculous (stuff like "your device has a virus, click here to clean it up")

[0] - https://listeningfacts.com/

[1] - https://www.fda.gov/food/nutrition-education-resources-mater...

[2] - https://community.spotify.com/t5/Spotify-for-Developers/Upda...

[3] - https://www.reddit.com/r/lastfm/comments/1mnk5wj/listening_f...

An alternative tool to Extract/Load data via YAML, Python or CLI.

* pptx-grep - find text across multiple powerpoints, yield file/slide no and text excerpt of match

* pptx-dump - dumps extended info about a powerpoint, such as number of slides, applied master slides, used fonts etc.

* pptx-lint - allows to define validation rules for pptx based on content and/or formatting. E.g. presentation must not contain word "TBD", all text must be formatted in Arial etc.

https://boonerankings.com/

Our first dinner was with 13 friends and has since grown into a group of just about 1,000 members. Last year we generated around $140k for local restaurants on off nights (dinners are on Tues and Wed when business is slow).

Now we are working on evolving into more of a lifestyle brand for people who love food. I'm currently working on our clothing line and new site, which we quietly launched a few days ago (there's still a few odds and ends to finish): https://www.deadchefssociety.com. Would love any feedback!

https://www.memelang.net/

So basically, I'm building a system where users can query all of that unstructured data and add more with a little less friction.

a fun side project to track Sumo stats.

Every two months there’s a 15-day tournament where 670 rikishi(sumo wrestler) fighting ~160 matches each day. I’m recording all the results and kimarite (winning moves) into a browsable database with charts and videos.

Recently I have been using Gemini to process and edit the daily match videos. It works surprising well. It can detect the start/end of each bout, recognise the wrestlers and assign the correct rikishi id to them.

Still early, but if you want to get into Sumo feel free to join! Its fun to watch and the matches are quick!

Creating a file generates a self-sustaining pattern of packets circulating through the network, and editing it changes the flow itself. Multiple users can edit the same file simultaneously, because the file isn’t tied to any machine—it’s in the network.

The interface is familiar if you’ve used ed, with commands like append, delete, and substitute, but behind the scenes it’s all live traffic. You can even discover existing flows and jump into them in real time.

It’s a Linux proof-of-concept using raw sockets, and the goal is to explore what files could be if we thought of them as living, circulating processes rather than static storage.

https://github.com/DantrazTrev/nerd

Focusing on ergonomics improvements. Just released an improvement to the __repr__ for Invalid types.

Potentially working on expanding the ability to generate validators from arbitrary typehints, ie `get_typehint_validator(list[str | int])`. It has good coverage, but I suspect I'm blind to some obvious holes. Would love feedback!

I already have a similar project for Typeform, for which someone reached out to me to see if I can help them integrate it into their project.

This project is very similar to that, but it implements Jotform.

The past couple months have been fun since I've implemented a lot of new highly-requested features into the site's city heatmapping capabilities. One thing I've found motivating is having my own private changelog that shows screenshots of feature requests people have given me, and then dates for when I finally finished those features.

It's easy to forget how much stuff you've built in a month or two, sometimes.

- comes with common SaaS features pre-built (crud, blog, auth, etc.) - import templates from the framework until you want to customize them - create forms with just a zod schema - good docs, typescript interfaces, a CLI for common tasks, and MCP for your AI agent

If you're building something now or want to - I'd love to help. Could use the experience to make things easier through my framework.

www.socratify.com

It focused on critical thinking and communication skills by having dialogues about recent news and announcements at the companies you want to work at. Have a 2 min dialogue and get feedback about how you think and speak.

Think of it as a Duolingo for your career goals

You can randomize and schedule images to show up at the link as well. Super useful for marketing, maintaining screenshots on a website or in documentation, etc.

Would love to hear if anyone wants to use it!

Features: Chat with page, fix grammar, reply to emails, messages, translate, summarize, etc.

Yes, you can use your own API KEY.

please check it out and share feedback https://jetwriter.ai

It's ~90% production-ready. We use it internally to move files between containers and hosts (especially when volumes aren't mounted), and for WFH employees to exchange large files without a relay server. For huge files, there's resumable upload to our infra-backed server — fast global downloads included.

The CLI will also support receiving files via WebRTC, but that feature hasn't been released yet. It is open source (https://github.com/nuwainfo/ffl), but the README hasn't been updated yet and the code is not synced with the latest version (working on these).

Another production-used tool I'm working on is MailTrigger (https://www.mailtrigger.net/) — a programmable SMTP server that turns any email into a message on LINE, Slack, Teams, Telegram, SMS, or basically anything. If your app can send email, it can trigger multi-channel notifications with zero extra code.

Think of it as “SMTP to Anything,” or an email-native IFTTT/Zapier.

It supports JS and WASM for preprocessing, routing, and automation — you can write custom logic, auto-reply with LLM-generated messages, or forward alerts intelligently. We use it for price drop alerts, server health monitoring, and integrations with Jenkins/Sentry to push incidents to our DevOps Telegram channel.

Also experimenting with LLM-assisted rule creation: you can define notification logic in natural language instead of writing code — for example, auto-reply with an LLM-generated joke or handle customer support queries dynamically.

Docs are more complete than the website (which is still evolving), and the pricing page is currently a placeholder. Already running in production for us and a few early adopters.

It’s a daily puzzle game that combines soccer and chess.

Currently implementing custom markdown elements for more advanced things like forms and buttons.

I'm actually in the middle of a complete redesign of the AI layer, but there is a POC video linked from the GitHub README that demonstrates the interaction I'm going for using an earlier version. The POS is a very bare-bones system where the "kernel," as it were, is implemented in Rust. There's an MCP atop that to allow the AI and UI layers to drive the POS. Stores may be implemented as extensions that plug into the POS kernel, and that's where language, currency, item databases, and such are defined. The AI cashier knows what items are for sale, how to modify items (in a restaurant context), how to translate from other languages, how to interpret what the customer actually wants, and seamlessly lead the customer through a transaction.

The current code is quite ugly and full of a lot of unfortunate hacks, but it was a good education. The new design puts the AI much more in charge, without as much code-level orchestration. I'm applying a lot of my knowledge from the retail POS and self-service checkout domains to this, as well as learning a lot about applying AI to a "legacy" software domain.

His English is okay but we've had miscommunications. We can itemize tasks, request quotes, delineate with photos, and do basic scheduling+billing.

These docs are gonna be used in a product for medicare brokers (if you are/know one please reach out open enrollment starts Nov.1!), and the pipeline is horizontally scalable to ingest updated 2026 plans overnight @ start of open enrollment (though some companies are posting updated plans earlier)

There are some clever tricks at play but mostly it's bog-standard browser automation; I'm also in an interview process with 2 entities (one funded startup and one massive corporation) talking about web automation roles, and while it's frustrating that they're moving so slowly it's working out to give me time to build this well.

My take is that for years, ORMs have hidden the power of PostgreSQL behind generic, database-agnostic abstractions. This made sense in 2010, but now it's a bottleneck.

Typegres rejects this. It's a "translator, not an abstraction," designed to express the full power of PostgreSQL (all statements, built-in functions, etc.) in a type-safe TypeScript API.

The latest killer feature my take of "object-relational mapping done right": class-based models with methods that are actually composable SQL expressions. This lets you extend your tables with expressive logic and fully-composable relations.

It's easier to show than tell. Take a look: https://typegres.com/play

Future-proofed and will work on AI spam in the future too, unlike current spam filtering methods.

Nothing to demo yet, but hopefully I'll have something soon.

The game is available on Steam for Windows, Mac and Linux. The demo contains the entire first episode with 30 levels for anyone who wants to try it out.

https://store.steampowered.com/app/3624050/Jolly_Land_Advent...

https://wanderfugl.com

Punch TV: Fighting Game Show

https://play.google.com/store/apps/details?id=com.fourfats.p...

https://apps.apple.com/app/punch-tv/id6477147072

https://store.steampowered.com/app/3964520/Punch_TV/

Something that doesn't nickle and dime you, very cheap (perhaps even open source), has all of the extensibility of a modern ERP, a great UI, and handles complex use cases (revenue rec, expense management, inventory cogs, etc).

I feel like this is solving a real problem, but have no idea how to break into the industry. Just trying to solve my own problems for business accounting but would be nice to know other folks would be interested.

> https://github.com/vinhnx/vtcode.

I’m working on https://www.hessra.net/, an identity + authorization service built around [Biscuits](https://www.biscuitsec.org/) instead of JWTs. The goal is to decompose auth primitives so they’re easier to use in service-to-service cases, while also showing off what Biscuit tokens make possible.

JWTs feel like problems waiting to happen. I think biscuits give stronger guarantees and are harder to get wrong.

One piece I’ve shipped is an identity token that can be delegated offline. For example, “company:alice” can delegate to “company:alice:agent,” and that token can then be used to request an authorization token. This makes for a neat API key model: you can issue a simple opaque identity token to your customer (e.g. “customer123”) without having to maintain a DB of hashes/expirations, since those are encoded into the token. Later, you can upgrade security by exchanging the identity token for an authorization token, or let customers delegate access (e.g. “customer123:marketing”).

I’ve also been experimenting with higher-order authorization flows:

• Service chains: each step in a request’s path (edge → app → DB) can add attestations, so later services can validate the full chain.

• Multi-party authorization: requiring two independent services/orgs to co-sign an authorization token, useful for cross-org or on-prem deployments.

Right now I’m building an OAuth 2.1 profile where the identity token replaces a refresh token and the authorization token stands in for the access token. I’m especially interested in hearing where people find OAuth clunky in practice, or stories from folks who’ve built auth systems with other token types (macaroons, biscuits, etc.) or for use cases where OAuth didn’t fit well.

It will glue specialized APIs (search, scrapers, tools, etc) so that you rarely need to leave it

There's been a couple attempts in this space before but they usually seem to peter out after a while. I'm hoping to avoid that by staying flexible and focusing on just managing files instead of creating a new compose-like DSL. But even if it doesn't become popular I'm just happy I don't have to manage my homelab with Ansible anymore :) .

[0] https://primamateria.systems/

https://vyprsec.ai/

Yep, you read it right. 0 false positives. We scan the whole codebase for possible vulnerabilities, rank them, write the proof-of-concept for exploitation, spin up the software in a sandbox, and then attack. All of them happen autonomously without human involvement.

The end report? Only verified vulnerabilities are being reported without noise.

Already reported some unknown vulnerabilities in open source projects. The good thing is we're just getting started.

Building on my 2.5D renderer and now going to introduce 3d models for funsies.

Currently writing a run-through of it to publish on my website. I'm not sure how secretive to be - I think I just want to be the first to actually release my findings. In my post I'll detail the steps to reproduce my results so more people can look into this.

So far I haven't found any critical ways to (ab)use this access control system weakness, as it only typically applies to the outer layer of physical security.

- Mixtape sharing platform for midwest emo[1] which is a genre I've really gotten into over the past few years. The community is pretty strong on YouTube for creating "mixtapes" so I wanted a spot that was just for these videos.

- PhotoForge[2] Photographer's companion app which can help me choose photos using a Tinder-esque swiping mechanism. It also has some AI stuff for generating Instagram descriptions. Finally has a watermark tool. Still trying to think of other stuff to add. This was an AI code weekend project so it's like a house on stilts at the moment but I plan to give it some more love soon

[0] - https://www.youtube.com/watch?v=CXdpSfDWbGY

[1] - https://www.youtube.com/watch?v=KS4M4WpmrY4

[2] - https://www.photoforge.fun/

Whilst I’m recently really critical of most AI posts here, this wouldn’t have been possible without AI, but mainly because AI could feed my curiosity and barely any riddle was unsolvable, when I put it into pieces and combined it with debugging (and checking docs). Actually most riddles on my level weren’t unsolvable before, but AI reduced the friction and speed of learning for me. This actually goes beyond coding. In life I just ask and learn a lot about, washing, cooking and domain-specific terms.

Tial mi vorkas por krei liston de ĉiuj mal- vortoj kun sen mal- alternativoj. Fakte ĝi ankaŭ povas servi la kontraŭan celon, provizi pli ĝeneralajn mal- vortojn kiam oni deziras krei verkon pli facile akirebla de ĉia nivelo.

Mi planas eldoni ĝin denove ĉe https://eo.wiktionary.org/wiki/Aldono:Pri_antonimoj kiam mi finis, sed nun estas pli facila progresi per citilaj kaj vidŝangaj kromaĵoj ja provizata ĉe https://fr.wikiversity.org/w/index.php?title=Utilisateur:Psy...

It looks like Markdown is having a bit of a heyday with it being the default mode of docs for AI coders. And it became apparent that there is no simple, but powerful Markdown viewer for the Mac, so I made one.

It supports all the usual Markdown formatting but also diagrams and equations so you can get Claude to not only write up your system docs but also supply a diagram of the database structure, logic, or AWS services.

It would be cool if you gave it a go :-) It is in the Mac app store "ViewMD"

https://elmo.dev - a tool that automatically builds a searchable knowledge base around your project based on your conversation with coding tools.

It works automatically and doesn't require your attention. To build KB it uses same tool as you (claude/codex/gemini) so it uses the same quota and you don't have to pay additionally for the AI running it.

The result is ./elmodocs directory in the root of your project. You can reference CLAUDE.md/AGENTS.md/GEMINI.md to this directory or directly include the whole directory or its parts into the coding context.

https://devnoty.com/templates/nextjs

https://jazzear.com/

Now I'm working on a smaller app for jazz musicians to manage their tune list and act as a tool to help practice and review tunes. I wanted this app to tell me what tunes on my list I haven't played in a while (and might forget), or try different keys or exercises on the tune and track what I found difficult.

I suppose it has moved from “what are you working” to “what have you worked on” territory, but since I wrapped up the website just about a week ago it still feels quite fresh.

Always interested in feedback and what folks find useful! It’s focused on the mechanics of writing understandable software, which I think is especially important in the age of AI slop.

hello@carbonimpacthq.com

We are a small team but growing quickly.

Always been fascinated by repurposing established protocols for unintended uses - DNS is everywhere, passes through firewalls, and has built-in caching. Seemed like a fun way to deliver location data without HTTP APIs.

Super niche, definitely a bit odd, but that's the appeal.

I'm building an app to help people memorize Kanji by turning the characters into vivid, memorable images with accompanying mnemonic stories.

I think AI image and video models have reached a point where they can offer a completely new approach to language learning.

Next, I'm planning to add features that use AI to generate comic strips (using Seedream or Nano Banana), songs (using Suno) and videos (using Veo 3 or Seedance) to make learning Kanji even more engaging.

It's a double-entry personal finance tool where you own your data. It’s local-first, syncs across devices, and everything’s encrypted in transit. Soon with multi-currency support. Currently targeted for desktops.

It's interesting in many way. Using double-entry (it's a perspective shift and a power tool), the challenges and advantages of building local-first app, UI/UX & visualizations, privacy and more. For personal apps, local-first is a good fit.

Super simple utility page, offline, to convert lists to things, mainly for SQL usage.

1: https://lookaway.com

https://obsidianstarterkit.com

Got rejected by YC '24 but wanted to build it anyway

Just started fundraising for seed round

This makes it possible to use your own, dedicated MCP server instances from, for example, n8n workflows, without thinking about infrastructure.

https://mcp-as-a-service.com

Happy lets you spawn and control multiple Codex/Claude Code sessions in parallel. Happy Coder runs on your hardware, works from your phone and desktop, costs nothing, End to End encrypted, and permissive MIT License.

https://github.com/slopus/happy

Happy Coder is a unix style "do one thing well" project.

The goal is zero workflow disruption. I want to be able to run CLI coding agents on any internet connected computer, and control them with my phone. Happy has a command line wrapper for Codex and Claude Code that let you start a session in your terminal, and then continue it from your phone with real time sync. So type in your terminal and see it on the phone, type into your phone and see it in your terminal. So you can switch back and forth.

There is an optional voice agent some contributors have been hacking on that lets you talk to the voice agent first, and the voice agent then writes prompts for Codex/Claude Code and answers questions about what the coding agent running on your computer is doing/did. The voice agent feature is pretty neat, but in my opinion needs a bit more iteration, so any ideas or help would be awesome.

My team suffers from dependency creep. As soon as your system grows, the number of dependencies skyrockets. In Python/Javascript projects it's especially hard to determine which dependencies are not used anymore.

Pruno saves time for your team by automating this work. It's still WIP, but I'd like to get feedback. How are you dealing with your dependencies?

I live in Viet Nam, and driving through bad storms this time of year is pretty miserable, and they happen fast and are local enough that weather prediction is not terribly useful.

There are a lot of problems with EMI. Lots of ungrounded brushed motors everywhere that make the RF bits hard. If I succeed, I'll publish the PCB designs.

I've also got some educational products in production right now, about Vietnamese history. I'd share a link, but my website probably can't handle the traffic right now.

https://www.autonoly.com.

It goes to extreme lengths to ensure great performance, i.e. rewritten most server-side parts of git from scratch, so there is no "exec"-ing git nor calls to libraries like libgit2. The frontend should also be very fast thanks for HTMX.

[1] https://gitpatch.com

https://solar.franz.hamburg/

Kind of have been wasting time with Cloudflare workers engine. Trying to build a system that schedules these workers for a lightweight alternative to GitHub actions. If you are interested in WASM feel free to reach out. Looking to connect with other developers working on the WASM space.

https://masterlist.fi - shareable todo list without login

https://hockeytactic.com - tactics board for ice-hockey and floorball with live collaboration

This is the biggest marketing effort I've done for those projects in months :)

https://ip-sonar.com/

The main idea is that tests should just be Python: plain `assert` statements instead of custom matchers, no fixture magic, and when tests fail you get readable diffs that actually show what went wrong. Tests can be simple functions or structured with steps that self-document in the output.

https://vedro.io

I would be very happy to receive any feedback!

github: [username]/escape-rope, /escape-rope-ui | UI demo: escape-rope.bhmt.dev

Personal side project: extensive cleanup of my family's place. I'm just now approaching a decent first pass at the outside, and have to tear apart a basement next. It's taken most of this year. It's not the specific reason I've farmed collecting search results off to a bot

For-fun thing: CTF puzzles. I'm not very good at them, but they're useful for other things. I fell down the scraping rabbit hole this way, and I'm currently using a series of them to finally get some exposure to Python. I also have a writeup half-written about this exact process

It lets you log symptoms and triggers, but the bigger vision is being able to discover patterns, ask questions about your own data, etc.

Being able to answer questions like “Do my flare-ups correlate with stress?” or “What foods make things worse?” backed with personalized data has been helpful with my own flares.

Still early, but curious to hear thoughts from folks!

The core idea is to leverage ClickHouse's incredible columnar performance for log analytics while providing a schema-agnostic interface that works with any log table structure. It supports both simple search syntax for quick queries and full ClickHouse SQL for complex analytics. Also it has proper RBAC: Team-based access controls for multi-tenant environments.

Off late I have also added some AI features:

  - AI-powered SQL generation - write queries in natural language

  - MCP (Model Context Protocol) server integration for AI assistants to query your logs

Built with Go + Vue.js + TypeScript. Currently handles millions of log entries daily in production environments at my org. The deployment is just a single binary deployment with a SQLite DB.

Would love feedback from the community! GitHub: https://github.com/mr-karan/logchef

Nothing good enough to share as its own post, but its something I'm working on that people may be interested in.

https://github.com/LegoStormtroopr/unit-separated-values

There are some out-of-the-box catalogs and styles shipped with the default installation, but they are quite limited and fairly well hidden—which is not surprising, given that Civil 3D is a huge beast. As a result, they are not commonly used.

When people think about Civil 3D, they often assume it requires BIM modelers (in a sense, just glorified drafters) to create all the necessary catalogs and styles, and to assist with their use.

My Civil 3D plugin will:

1. Make standard, market-compliant catalogs and polished styles available to engineers at large. Think of it as the WordPress theme provider equivalent.

2. Make the entire process easy and painless through the plugin, with prominent buttons for quick access.

If the plugin is done well, there will be less need for BIM modelers, since for a fee, engineers could simply purchase catalogs and styles that are so easy to use they require no technical training.

As a side benefit, I also get to explore how LLMs can help me write code. It has been a while since I last updated my AI usage policy [0], and I look forward to revisiting it.

[0]: https://civilwhiz.com/my-ai-usage-policy/

What I’m trying to understand is whether it is viable to pay people ~$5 per week for sharing their location data and demographics based on a 90% share of revenue from sales of data products built on that data. (But without ever selling or exposing individual level data).

https://building.shepherd.com/roadmap/launch-our-tbr-app-to-...

I'm working on improving UX and simplifying deployment a lot. In the next release, a single docker run will be enough to get a working web analytics service with minimal resource usage.

[0]: https://www.prismeanalytics.com [1]: https://github.com/prismelabs/analytics

Here are some of my first results (free PWA):

https://fretool.dev-zoo.net (Fretboard visualizer)

https://atoy.dev-zoo.net (real time audio slowdown and looper)

https://harptool.dev-zoo.net (Harmonica helper)

Feel free to give my repos a star on GitHub, thx

The idea is to be able to publish campaigns globally in any location/language and also get qualitative recommendations on what to improve. For example, if people have typos in their search terms, Rudy recommends to add it as a keyword so it can maximise the conversion.

For over a decade, I’ve thought about how most people seem to resist the advice about money. And also how all advice is based on the same idea: seeing where your money went and making monthly plans based on that.

I think people feel that this is a poor match for how money works. So they improvise. And because we tend to not discuss money with others, they improvise on their own. What this typically looks like is checking their balance and trying to pace things.

I’ve been trying to design the app around that. Providing support to what seems like a natural, instinctive approach to managing money.

https://apps.apple.com/app/id6443515404

Standard system notification comes at about 10%, and most of the time, in my case at least, whenever I miss that, the result is "laptop shutdown amidst an ongoing video meeting" or something like that. (Basically, too late before I act)

Just so that I don't miss the reminders, the app will show an overlay window with some text, following my cursor, and a custom sound.

I built a version this weekend, and am current doing a dogfooding exercise.

So over the past few years, I have seen how contexts have been steadily growing in AI apps. And while the context lengths of LLMs have also been increasing, they are still effectively about 200k tokens. The performance drops off a cliff after that (you might have noticed it as well with long AI chats).

It is a simple API that prunes away irrelevant parts of a context for a given prompt, a.k.a. context-aware pruning. Integration is super simple: just an extra API call before the final LLM API call. You can get an API from the website.

I would love to chat if this is something that is relevant to you and if you have any feedback on what we are building!

[1] https://scaledown.ai

https://github.com/amuta/kumi/tree/codegen-v5 (see ./golden for more context on the compilation/codegen. I barely knew what a compiler was before doing this so I might have just created some nonsense )

https://store.steampowered.com/app/3627290/Botnet_of_Ares/

It annoys me how much a bad trailer can spoil the movie, so I made this platform to rate trailers how "spoily" they are and how good they are. To my surprise, you find some great trailers without many spoilers, but then you will have trailers which are basically a 3-min summary of the movie.

[0] https://trailerspoiler.com/

https://pagecord.com

Pagecord is free with a very full-featured (and cheap!) premium package. Email newsletter, custom domains, privacy-respecting analytics etc.

Source is available. Ruby on Rails:

https://github.com/lylo/pagecord

My initial announcement got the top spot in "What are you working on? (February 2025)" https://news.ycombinator.com/item?id=43157056 but now I'm a lot further, there's a website https://comper.io and the company is getting incorporated within two weeks.

Last week I showed it off in the Feeling of Computing Meetup (fka Future of Coding) - the recording is here and the reactions were extremely positive https://www.youtube.com/watch?v=3-rg-FPZJtk

I'm opening the private beta soon, where I mix using the product with consultancy, to get better customer feedback. Not sure if that will work, but I don't have all the features yet for bottom-up adoption.

So I built Riff Radar - it creates playlists from your followed artists' complete discography, and allows you to tailor them in multiple ways. Those playlists are my top listened to. I know, because you can also see your listening statistics (at the mercy of Spotify's API).

The playlists also get updated daily. Think of it as a better version of the daily mixes Spotify creates.

https://riffradar.org/

https://github.com/dahlend/kete

I'm working on modeling the motion of observed dust particles coming off of comet 67P, here is are some example 3d plots:

Example of rocks ejected from one position and their possible motions: https://dahlend.github.io/67p_beta_dust.html

Trying to determine possible orbits from a set of observations (the straight lines): https://dahlend.github.io/67p_dust_orbit.html

Shout out to pyvista for making these great 3d plots possible, a little less ergonomic than matplotlib, but it can export directly to html.

Postply uses full-context to generate better replies on X, Instagram, Facebook & LinkedIn. It supports custom reply profiles and styles for support teams and social media managers. There are clearly a lot of AI replies on social media already, but they are really generic and bad. With Postply.com I'm hoping it will help people generate better and more meaningful replies.

Here's the catch: most creators study top accounts but can't replicate their success. They miss the patterns.

Analyzed 1M+ tweets from top performers and built AI that doesn't just copy - it adapts their winning frameworks to your voice and niche.

One user went from inconsistent posting to systematic growth. The content quality jumped. The engagement followed.

Not promising follower counts. Promising you'll finally understand what actually converts on this platform.

see https://github.com/van-sprundel/partijgedrag

You can charge as little as 0.000001 USD per request. The platform uses our own system for tracking usage, which is settled through Stripe. No crypto, tokens, or wallets.

If combined with subscriptions, the pricing can work similarly to mobile plans, where monthly plans become cheaper above a certain usage threshold.

Looking for more developers to try it and share feedback.

Resources: integration guide (https://smalltransfers.com/merchant/docs/integration-guide), a quick walkthrough (https://youtu.be/WQW5fiUFNRk), a Next.js template (source code: https://github.com/smalltransfers/nextjs-starter, live demo: https://nextjs-starter.smalltransfers.com/), an AI template (source code: https://github.com/smalltransfers/ai-starter, live demo: https://ai-starter.smalltransfers.com/).

This uses phaser, standard web tech, wasm (built from Go engine running on server).

Trying to build browser games that feel more like Steam games.

Unfortunately rocksmith doesn't seem to have a sheet music view, so I'm trying to write something that will take the input from my audio interface and put it through a note detection library (and then compare to a midi for an accuracy score) to make my own version.

So if you have an AI Agent, please send it there. I wanna know how they identify themselves.

Used by enterprises for compliance, reporting and answering questions like, who owns this ai model, whats the monitoring plans, where is it running, what approvals does it have, what policies are applicable (geographic etc).

https://rategame.io/ and on the app stores(I really recommend the app if you want to check it out, especially on a phone)

We've expanded on the concept with rating stadiums, creating lists, voting for player of the game and more as we are trying to become the letterboxd for sports.

Right now we're focusing on reference docs and soon the app will be able to write full documentation content.

We want to focus on incremental changes to docs (one PR at a time) so the content is easy to verify and merge.

Attracting new monthly sponsors and people willing to buy me the occasional pizza with my poor HTML skills.

https://brynet.ca/wallofpizza.html

Codex in the cloud has been leveraged to do 95% of the work and Claude 5%. We've output 10.5K LoC and 774 individual tests to ensure compliance to the spec.

Lately I've been feeling like we're living firmly in the future. This would easily be an 8+ month project on my own not including the tests, yet we're now on track for completion in 10 days. A min. 25x speed increase is a crazy level of productivity for me and it's hard to believe I'm still seeing articles claiming that AI coding isn't productive.

A little search engine I'm building for RSS fans, lets you

- create custom RSS feeds via search query API - search RSS feeds / blog posts - find similar posts / blogs

Over time, the project has grown to now support more than 17 platforms, thousands of users, and has been growing organically.

As of most recently a major feature I've been working on is full chat history based memory. Being able to remember and recall every conversation you've ever had across multiple supported AI tools, similar to the reference past conversations feature in various AI apps. This has been pretty intense and fun. Ingesting tens of millions of tokens per user, and doing complex multi-stage RAG on-the-fly across this vast dataset with a tight latency target for UX.

The project is MemoryPlugin: https://www.memoryplugin.com

Another project is a RAG app that's built specifically for books. No "we work with your receipts, and legal documents, instruction manuals, product documentation, lecture transcripts, your dogs novel, the script for a play and everything else possible". I wanted something tailored for books, specifically, non-fiction books. When you try to work everywhere, you can not deliver an amazing experience for any one specific use case. AskLibrary is tailored for non-fiction books, so everything from the answer generation pipelines, to the ingestion pipeline, and various other features are all designed for this specific use case. https://www.asklibrary.ai

The idea is simple: * See where your Azure spend is going, without learning all the ins and outs of Azure Cost Management. * Get alerts when something unusual happens, with the root cause explained right away.

Still in preview, so I’m mostly looking for feedback from people who deal with Azure day to day. Early access is available if you want to try it!

So, I decided to build a practical implementation of this system with a central Orchestrator that manages a fleet of implicit or explicit Subagents. Each subagent is a specialized, isolated AI agent designed to perform a specific subtask. More details in the repo README at https://github.com/skanga/conductor

https://github.com/tomaytotomato/location4j

It uses NLP to try and understand and resolve a location from some free text to either a City, State or Country.

e.g.

"NY USA" -> "New York, United States of America"

"LOS ANGELES, CA" --> "Los Angeles, California, United States of America"

I have some interesting bugs with collisions in concepts e.g.

- Mexico is a country but you can also call Mexico city

- New York as a city exists in multiple places and is also a state in America

Got some interesting issues with

Hobby. Very rudimentary, not everything working yet.

Think ansible for your user account (except it will definitely not be ansible for your user account).

Whenever I have a new machine, I do the same steps over and over again:

- Installing some packages (like make)

- Setting up an ssh key

- Cloning some git repositories

- Setting up dotfiles

- Installing rustup / rust

- …

Until recently I tried doing all of that with a bunch of bash-scripts, but that turned out to be messy and not a joy to maintain. So now tried a slightly different angle with a rust tool that you can just pull out of the CI, no dependencies, and it will setup everything (for me).

Business Name Generator Generate memorable, brandable business names using advanced AI technology. Get domain availability and social media username checks instantly.

Initially I released it for obsidian: https://news.ycombinator.com/item?id=39764919 but realised it works with just markdown so I rebranded the app, added some new features and increased prices.

It is a DNS service for AWS EC2 to keep the ever changing IPs when you cannot use the Elastic IP like ASG or when you don't want to install any third party clients to your instances.

It fetches the IPs regularly via AWS API and assign them to fixed subdomains.

It is pretty new :) still developing actively.

It started as a way to learn RTOS internals, and over time it has grown into something with lots of nice features. I’m even using it in a dirtbike anti-theft tracker I am building.

Also, this month I did a weekend challenge to build an embedded software parameter DSL and compiler. Its goal is to let firmware developers define configuration values, thresholds, constants, and other application-level parameters in a structured, human-readable format, and compile them into binary data that the firmware can directly use.

https://github.com/raphui/epc

Happy to get any feedback :)

The main idea is that you don't need to configure anything, simply send us the data and we should figure out evals for you.

If anyone is building with realtime voice send me an email at username at Gmail and I'll try to help you improve your tool for free (In exchange I get to talk to real users)

Right now I’m adding few of the most requested user-requested features (vertical Dock support etc.) and working on refining it for Tahoe release.

It's basically inspired by LighterPack[2], but LP is left abandoned and the UI is quite hard to work with, unfortunately.

[1]: https://github.com/eze-kiel/carryless

[2]: https://lighterpack.com/

The Problem: News fatigue is real. Reading 50+ articles daily (from hundred of different sources) to stay informed is unsustainable, but traditional aggregators just dump links without context.

Wikli uses a three-stage pipeline:

Scraping & Processing (Cloudflare Workers): RSS feeds → content extraction → AI classification Semantic Clustering (Python): Claude groups related articles across sources into coherent stories Digest Generation: AI synthesizes clusters into readable reports with context and TLDR

Technical Highlights:

Cloudflare Workers + PostgreSQL for scraping infrastructure Hybrid content extraction (Readability + Puppeteer fallback for tricky sites) Claude Sonnet 4 for clustering and synthesis (outperformed embedding-based approaches) Theme-based filtering with relevance scoring (0-10 scale per article) Telegram bot with stateless approval workflow for editorial control

What's Different:

Semantic clustering beats chronological or source-based grouping Context from previous digests prevents repetition Human-in-the-loop via Telegram for quality control (can edit title/approve digest) Open architecture: separate Brief Generator (Python) and Scraper API (TypeScript)

Stack: TypeScript, Python, PostgreSQL, Drizzle ORM, Claude/Gemini APIs

The system handles rate limiting across domains, AI API throttling, and includes a DataManager abstraction for centralized data operations. Currently live in Italian at wikli.com - language-agnostic by design but focused on the Italian market for now. A the moment running with two topics (AI innovation and Inter Milano Football Club) via Telegram and wikli.com website.

Happy to get any feedback.

https://nativephp.com

https://bifrost.nativephp.com

A two-man team, we're enabling PHP developers to get into mobile app development as easily as possible - no need to learn new languages, no new skills, just a few commands and away you go.

NativePHP is the library. Bifrost is the build and release service, getting apps into the stores faster than anything else.

This month we're planning to release the first fully open source version of the Mobile package.

How's it going?

We've sold over 2,000 licenses since May. We built Bifrost over the summer and it already has almost 300 monthly subscribers.

We just gave away another 1,000 licenses to the African PHP community.

So, I've been working on something... interesting. It's an AI assistant that can actually represent candidates in the first round of job interviews. Yes, you read that right—because apparently, we've collectively decided that showing up to your own job interview is so last decade.

Here's how this magnificent creation works: The system ingests everything about a candidate—CV, professional experience, cover letter, LinkedIn, GitHub, portfolio, and any preferences they've specified (salary expectations, location, contract type, the usual existential career questions). Then, armed with this treasure trove of personal data, my AI conducts automated interviews directly with HR departments or their equally soulless chatbots.

In real-time, it generates responses as if the candidate themselves were speaking—complete with soft skills, communication style, and structured answers. Because nothing screams "hire me" like algorithmic authenticity. If it encounters a question beyond its training data, it politely pings the candidate: "Hey, need some input here before I completely botch your career opportunity."

What this technological marvel offers: 24/7 Availability – Candidates can "attend" interviews while sleeping, working their current job, or contemplating the futility of modern employment practices. The AI never sleeps, never complains, never has a bad day.

Personalization – Responses tailored to each candidate's actual experience and skills. It's them, just... optimized. Debugged. Free of human error like nervousness or accidentally mentioning you follow your passion for underwater basket weaving.

Performance Analytics – Post-interview analysis of how well the candidate matched job requirements. Because self-awareness is overrated—let the machine tell you how you did.

Training Mode – Candidates can practice various interview scenarios and get feedback. Think of it as rehearsing for the day when neither interviewer nor interviewee is actually human anymore.

And yes, the circle closes beautifully.

I'm building a system where AI talks to AI about human employment while humans... what? Watch Netflix? It's efficient. It's scalable.

It's absolutely ridiculous when you think about it for more than thirty seconds.

But hey, if companies are going to screen candidates with automated systems and generic chatbots, why shouldn't candidates fight fire with fire?

Welcome to the employment arms race nobody asked for. I'm either solving a real problem or hastening our irrelevance. Probably both.

The way it works is the user registers / imports MCP (Model Context Protocol) servers they would like to use. All the tools of those servers are imported and then the firewall uses structured LLM calls to decide what types of action the tool performs among:

- read private data (e.g. read a local file or read your emails)

- perform an activity on your behalf (e.g. send an email or update a calendar invite)

- read public data (e.g. search the web)

The idea is that if all 3 types of tool calls are performed in a single context session, the LLM is vulnerable to jailbreak attacks (e.g. reads personal data -> reads poisoned public data with malicious instructions -> LLM gets tricked and posts personal data).

Once all the tools are classified the user can go inside and make any adjustments and then they are given the option to set up the gateway as an MCP server in their LLM client of choice. For each LLM session the gateway keeps track of all tool calls and, in particular, which action types are raised in the session. If a tool call is attempted that raises all action types for a session, it gets blocked and the user gets a notification, which sends them to the firewall UI where they can see the offending tool calls, and decide to either block the most recent one or add the triggering "set" to an allowlist.

Next steps are transitioning from the web UI for the product to a desktop app with a much cleaner and more streamlined UI. We're still working on improving the UX but the backend is solid and we would really like to get some more feedback for it.

https://www.longevity-tools.com

All of my interpreters and calculators have (or will soon have) a nice video walkthrough where everything is explained in detail: https://www.youtube.com/@longevity-tools-com

Everything is free

https://danielfalbo.com/university.md

[1] https://en.wikipedia.org/wiki/University_training_credit

https://devmote.net

It uses Go & SQLite, the nice thing is that the DB is readonly and baked into the deployed container. I use cron on my home PC to do the scraping, update the DB and deploy a new version of the site using Kamal

It's still going well, and I've been making a ton of progress lately by using AI agents. I'm very excited to launch my new homepage and pricing soon, plus some other really cool side projects that I've built.

I'm quite proud of this renaming tool as well: https://docspring.github.io/renamify/

I just finished some new features today and launched v0.5.0. The VS Code extension and MCP server are both really handy. I've been using them for quite a few different renames lately. This is one I did today: https://docspring.github.io/renamify/case-studies/deploy-req...

From my side, I've been working on a multi-lingual first words book for a baby. None of the published books have our mix of languages (which is fair enough, I don't think there is much of a market for it!) and so I decided to create our own. It's just images and then the word translated into three different languages alongside it (like a typical first words book). I used Google's AI for the images, and it has done a surprisingly good job of creating baby friendly images, with enough detail to spark interest.

The other tangential benefit is that I found it awkward to speak in my mother tongue, but having this book helps break that by having me speak in that language and then leads to it feeling much more natural in other contexts with babies.

This is not very technical project (though if I had the time it could easily become a fun project where people select their unique mix of languages and the book gets produced).

If anybody is in a similar boat and wants to produce their own version for their mix of languages then please let me know and message here - I will happily share the Canva file with you (you'll just need to write in the words yourself). (This idea of sharing is inspired very directly by Derek Sivers 'Sharing' idea [0])

0 - https://sive.rs/sharing

Building the retrieval and memory maintenance layer. Interesting problems around decomposing solutions into reusable patterns, ranking/deduping at scale, keeping latency under 100ms. Uses MCP so it works across IDEs.

Early benchmarks look promising. https://memco.ai if you want to try it.

https://github.com/haskell-miso/miso-lynx

It's a way to build truly native iOS, Android and HarmonyOS applications in Haskell using https://lynxjs.org and https://github.com/dmjio/miso, it uses a similar approach to react-native.

https://getlumen.dev

ios: https://apps.apple.com/us/app/vocabulary-flashcards-vocabuo/... android: https://play.google.com/store/apps/details?id=world.petr.vok...

Since then:

- I added 13 new quests, from arithmetic basics to Elementary Cellular Automata and Sudoku.

- Rewrote the Turing machine core in Rust, making evaluation much faster and able to handle heavier tasks.

- 102 players have joined, submitting 15000 solutions; 10 players have already solved every quest.

The hardest part turned out to be the storyline. I use ChatGPT to draft outlines. It does it quite well, but shaping them into something with real depth and atmosphere takes far more work than I expected.

Another challenge: since it's a competitive game, players quickly explored the edges of the rules. For example, submitting very long solutions that use transitions as a kind of memory. I love that kind of creativity, but it also undermines the original goal of solving a puzzle as efficiently as possible. So I've spent quite some time balancing mechanics to reward creativity without encouraging loopholes much.

The most fun part, though, is still inventing new puzzles.

[1]: https://bewcloud.com

https://github.com/Roshanjossey/code-contributions.

Users will go through a tutorial, add an HTML file and submit a pull request to the same repository on GitHub.

It’s a free app called Just for Today, inspired by a poem I found in the book How to Stop Worrying and Start Living (amazing book). - It’s completely free; - No ads; - No account; - All offline - Everything stays on your device;

The poem is a gentle reminder: - You don’t need to fix everything today; - You just need to be present — Just for Today;

That simple idea became the heart of the app.

Each morning, the app invites you to: - Set a kind intention; - Check in with how you’re feeling; - Practice gratitude; - Write a little — just for you;

If you try it, I’d love to hear what you think.

I've spent the last couple of months porting the compiler from Julia to TypeScript. That's nearly done, so I'm hoping I can post an interactive web demo next month!

https://mastrojs.github.io/

In a docs-first approach, before building the framework above, I actually first wrote the following guide where you build a static blog, and implement a to-do list app: once with plain JavaScript, then reactively. Finally, you run a server with a REST API, and learn about caching and different architectures:

https://mastrojs.github.io/guide/

https://instantrows.com

https://dotsjournal.app

Sort of like a digital bullet journal. You setup some rows of events you want to track, then just tap for when/if that events happens. It’s already helped me spot certain triggers for my migraines, which I can now minimize. My wife has been finding it helpful to diagnose sleep problems. I think it might be super helpful to others with trying to understand lifestyle choices and how it impacts their wellbeing.

About to roll out the beta. Hoping to have a full release by the end of the year.

It’s my first iOS app in 8 years! Learning SwiftUI after UIKit has been quite the shift.

It's been really fun writing this from scratch and trying to design a mobile-friendly API that fits the OTel spec. There's still work to do on OTLP export and various other features - if this project interests you, please do get in touch!

Rust cross-platform application leveraging egui.

Web preview: https://tritium.legal/preview

[0] https://github.com/amterp/rad

I'm currently building a prototype hardware component (essentially a large format touch screen) that people can purchase alongside.

[0]: https://tableslayer.com

[1]: https://github.com/Siege-Perilous/tableslayer

This document [1] outlines our key differentiators, and we’re now inviting beta participants to explore and test the technology.

[1] https://healthio.notion.site/Onida-Efficient-VLM-Architectur...

The ideas are in large part inspired by Better-Auth, which is built on top of similar primitives. I hope more libraries will be built in this manner, because I believe that it provides very nice DX for the integrator/end-user.

It's not quite ready yet, but I did write most of the documentation.

https://fragno.dev

None of my clocks tell the time.

They're all fully automatic GPS-enabled timepieces. For a couple of years I've been developing, hand-making, and selling these clocks that track the moon phase, the sun's position, etc.

My new idea is the tide clock "NautiKron." It's getting a lot of interest from US coastal buyers.

https://truediffs.com

Looking for feedback on use cases and session controls (machine2machine).

https://inspec.design

My read of the industry in terms of software is that it's split into 3 groups:

1. Interior visualisation (basically 3D renders) which largely target the what-if amateur market

2. Big, clunky and old software tools for professional interior designers working on huge projects, which works well but has that universal sort of mild dislike to strong disdain depending on the person

3. New players who want to replace the old clunky software

Seeing this, we decided not to try to overthrow the old all-powerful project management solution, but rather to replace a single process in the interior design workflow. And of course to do it very well.

You copy/paste your product page URL into it.

It scrapes your existing product images + additional context (using Firecrawl's API).

Then it uses Google Gemini vision model to generate recommended missing shots.

It suggests those with a confidence score from 0 - 100%.

Then it uses Google Gemini Flash 2.5 to generate the actual recommended shots.

You can download them and insert them in your product listing.

Personal projects, developing a habit of contributing my time to a large open source project (having only ever run my own very small ones), teaching newer users how to use that open source package by answering questions and making little example videos, beginning to repackage my notes on things into blog-publishable writing.

Really anything that will help me use brief moments of concentration span to rebuild my confidence in my own ability. It is like a snail ride through treacle but this is the first month-long span in nearly two years where I don't feel like I am falling apart.

3 WIP books, one on HPC

realtime Rogue-like game, played in a terminal, in a year 2100 CE post-apoc US dystopia, with adventure, comedy and serious messaging/lessons as well

But today I am writing documentation on presigned URLs and extending a customer's custom video processing pipeline at pushr.io instead.

Been enjoying using Omarchy and this is my way of keeping tabs on what's going on.

Right now I’m polishing the onboarding flow so new centers can import families, configure their billing cadence, and connect Stripe in under ten minutes. Next up is richer analytics (occupancy tracking and revenue health) and rolling out a guided setup for late fee policies. If you’re running childcare ops or know someone who is, I’d love feedback on the workflow pain points you still feel daily.

https://llmring.ai

is a unified interface across OpenAI, Anthropic, Google, and Ollama - same code works with all providers.

Use aliases instead of hardcoding model IDs. Your code references "summarizer", and a version-controlled lockfile maps it to the actual model. Switch providers by changing the lockfile, not your code.

Also handles streaming, tool calling, and structured output consistently across providers. Plus a human-curated registry (https://llmring.github.io/registry/) that I (try to) keep updated with current model capabilities and pricing - helpful when choosing models.

An MCP server and client are included, as well as the ability to help you define your aliases/models with an interactive chat.

It's a thin wrapper on top of the downstream providers, so you are talking directly to them. And it also comes with a postgres-backed open source server to store logs, costs, etc.

MIT licensed. I am using it in several projects, but it's probably not ready to be presented in polite society yet.

I first tried to expose the VDBE to public usage, so it could be easier to right hand-made bytecodes, but it would require an effort that I'm not quite have to a side project. So instead I'm extending SQLite's parser to accept things like `let <var> = <expr>`, and functions. Alongside, I'm doing a "standard library" so you could build web servers and stuff.

The thing I'm struggling with is managing execution state. I have the idea of doing transactional functions using function coloring (e.g async functions), so each function call opens a new savepoint, and the user could rollback a particular function call in case it got wrong. I put the deadline to be 31 October, if I manage to get this on time I'll post here on HN :)

For several years now, I've had a routine of collecting articles on topics that interest me throughout the week and then reading them over the weekend. To help organize and streamline this process, I created this website.

The main idea is to gather tech articles in one place and process them with a LLM — categorize them, generate summaries, and try experimental features like annotations, questions, etc.

I hope this service might be useful to others as well.

https://github.com/sutt/innocuous

The traditional use-case is steganography ("hidden writing"). But I see more potential applications than just for spy stuff.

I'm using this project as a case study for writing CS-oriented codebases and keeping track of every prompt and generated code line in a markdown file: https://github.com/sutt/innocuous/blob/master/docs/dev-summa...

My favorite pattern I've found is to write encode implementations manually, and then AI pretty easily is able to follow that logic and translate it into a decode function.

https://feedbun.com - a browser extension that decodes food labels and recipes on any website for healthy eating, with science-backed research summaries and recommendations.

https://rizz.farm - a lead gen tool for Reddit that focuses on helping instead of selling, to build long-lasting organic traffic.

https://persumi.com - a blogging platform that turns articles into audio, and to showcase your different interests or "personas".

It's less focused on the social, more on the jobs. With a limit on the number of job applications a user can make; sort of like Twitter, for job application count. And mechanisms to provide feedback to users. Basically trying to address a few shortcomings of LinkedIn as I see them (with other mechanisms in the pipeline).

But it has neither any jobs, nor candidates.

I'm not sure what the strategy should be to resolve that. I've tried a few things that haven't worked out yet.

Blobcache is content addressed storage, available over the network. Blobcache allow nodes to securely produce and consume storage. Configuration in similar to SSH, drop a public key in the configuration, and you're done. Blobcache is a universal backend for E2E encrypted applications.

Docs - https://github.com/blobcache/blobcache/blob/master/doc/0.0_B...

I'm also working on Got Version Control https://github.com/gotvc/got

Got uses Blobcache for storing file data.

Got is like Git, if you fixed all the problems with storing large files and directories in Git. There's no "large files provider" to configure separately. All the data for a commit goes to the same place. Got also encrypts all the data you put in it, E2E. If you've run into problems putting your whole home directory in Git, you might have more luck with Got.

Both projects are GPL licensed, FOSS. Contributions welcome.

https://kernl.us

Under ideal conditions (emacs bootstrap running in a loop with FUGC_VERIFY=1) it reproduces about once a day.

Under non ideal conditions it reproduces once a month.

Seems to have something to do with large objects maybe? Anyway, wish me luck. These low-probability concurrent GC bugs are the worst

I started building Rasterly as a side-project to be able to dynamically visualize drone and satellite imagery of any size. You can calculate and view spectral indexes too!

The goal is to make it really easy for drone surveyors, conservationists, researchers, and so on to share aerial imagery without anyone needing to download anything.

No customers yet. Focusing on improving the performance of the tile server and preprocessing of images, and of course trying to connect with potential users! Struggling to transition into a salesman though.

https://lexica.news

My brother and I grew up playing sports and remember the simplicity of home-made drinks we'd take to games that blew the likes of Gatorade out of the park. We aim to replicate the simplicity of home-made drinks with simple ingredients.

https://www.drinkiso.com/

Our whole value-add is based around the fact that most sports drinks or hydration drinks contain a lot of junk. We are opposed to the bullshit catch-all that is "natural flavors" and believe in product transparency and honesty. Our products straddle the line between fresh-pressed juice and sports drinks. Our prices are definitely on the higher end, but with scale, we can lower them.

We currently are in growth mode - and currently are one of the best selling products in the top boutique gym chain in the Miami area, as well as going strong in all SoFLA Equinox locations (except for the WPB location which isn't open yet).

We do sell online but shipping is a PITA as overnight shipping costs for cold products are astronomical. When we find a cheaper solution so I can ship around the country, I'll let everyone here know :)

Based in South Florida (Miami-Dade, FtL, West Palm)? DM me and let's meet up!

Basically an n-dimensional webring.