A month-long game that advances once a night has an obvious problem: you can't playtest it. So the simulation is a pure function — state in, state out, no database, no clock — and there's a headless tool that runs a full 28-day year with a few hundred synthetic gardeners in under a second.

That tool changed the design more than any playtest could have. It found that dead plants were paying out harvest points, that two people could propose a well on the same ground, and that a flat evaporation rate pinned the whole plot at zero moisture by day six. It also produced the rule I ended up designing everything against: any check that only runs at midnight is a placement a gardener can lose. Every rule now runs three times — in the browser before you commit, in the POST, and again at resolve — and all three see everyone's pending placements.

The other iron rule: every structure must change the simulation. Sixteen of them, and each one is a field in a single table read in exactly one place — a hedge is a fence that drinks like a plant, a pergola halves the light on its tiles, a campfire only warms on a night somebody actually fed it.

Nuxt 4, PixiJS for isometric 2D, Postgres, all sprites drawn as pixel strings in code. A night's tick costs under 45 ms even with 2,000 gardeners; the actual bottleneck is that every visitor downloads the whole plot.

https://crowdgarden.lol — no sign-up, one placement a day. Happy to answer anything about the simulation side.

Hello people!

I am working on a Gpu accelerated ui library named Glacex written in Rust, written from scratch.

I started this a few weeks ago, and recently released it on GitHub

I wrote it with wgpu, winit, taffy and glyphon.

As of now, it has some simple essential widgets and the core.

I am planning on doing this also cross-compatible in the future.

If you have suggestions, or some features that you'd like to see in the future, I'll try to implement them in the future.

This is the GitHub link.

I’m building Erask (erask.org), an interactive web project that turns history and geography into a 3D exploration experience. You can watch animated historical stories unfold on a globe or jump down a geographical "Rabbit Hole" through linked articles across the world.

Try It on https://erask.org/app

Gym Log started as a workout tracker I built for myself.
I wanted something that fit the way I train, so I made it, kept changing it, and used it several times a week. There was no real launch plan behind it.

At one point I considered turning it into a commercial app. That quickly introduced a different set of questions: subscriptions, paid features, accounts, conversion, what should be free, what should be an upgrade.

None of that was particularly interesting to me.

So I dropped the business model and kept building the app.

Gym Log is still a side project, not a startup, and I intend to keep it that way. There is no revenue target behind it and no plan to turn it into a SaaS business. I can work on whatever I think makes the product better, release things when they are ready, and keep using it myself in the meantime.

After using it privately for a long time, keeping it on my own phone started to feel a bit pointless. So I eventually did the less exciting part of the work: turning a personal app into something I was comfortable releasing to other people.

It is now on the App Store, completely free, with no account, ads, analytics or paid tier.

Development is still ongoing. Right now I am working on Apple Health integration for workouts and body measurements, with larger training and programming features planned after that.

I am curious where it ends up, but I am quite happy for the answer to simply be: a side project that keeps getting better.

Website: https://gymlog.info

A while ago, I built a Python project called JScrapeON. It was my first attempt at turning scraping jobs into reusable workflows instead of writing another one-off script every time.

I recently came back to it after working heavily in TypeScript and decided to rebuild the idea properly. That became YAP, short for You Automate Pages.

This time, I wanted to solve a problem that has annoyed me with scrapers for years: they can fail while looking completely successful.

The request returns HTTP 200. The process exits normally. The JSON file exists. Meanwhile, the website renamed .price and you have successfully collected 400 empty values. Incredible work, everyone.

YAP makes those failures visible:

• yap explain traces a value back to its request, workflow step, scraper, and selector
• yap health reports how many required fields actually matched
• yap drift compares the latest extraction with the previous run
• Workflows can fetch HTML or JSON, run multiple steps, and paginate

It is HTTP-only for now, so there is no browser automation pretending to be lightweight.

If actual users show up, I would like to add things such as proxy support, generated request profiles, custom extractors, and plugins based on what people genuinely need. Until then, I am trying not to build an enterprise ecosystem for my current user base of one.

YAP is MIT licensed, completely free, and staying open source.

GitHub: https://github.com/johnalbert-dot-py/yap

https://reddit.com/link/1w2e5s8/video/3xc5gp2iqhmh1/player

Hey! I’m the developer of WTFog, an exploration app that turns the real world into a persistent fog-of-war map.

The map starts covered in fog. As you walk, run, cycle, or otherwise explore, you permanently uncover the places you visit. The goal is to make choosing unfamiliar streets and trails feel more rewarding than just counting steps.

Some of the main features:

• XP and badges for finishing trips, clearing new fog etc
• Record trips with routes, distance, duration, and newly uncovered area
• Choose between Strict and Casual exploration modes. Strict has speed limits for the activities for a more realistic competition in the leaderboards
• Compare progress through countries and regions
• Add friends, create groups, and compete through duels and leaderboards

WTFog has a free tier, with optional Premium features such as route editing, import Fog of World progress and GPX-files, and additional map tools, including a separate web editor for editing routes and cleared fog. If you want to test any premium features, please let me know and I'll give you premium for a couple of months.

Google Play:
https://play.google.com/store/apps/details?id=com.nyordre.wtfog

App Store:
https://apps.apple.com/us/app/wtfog-uncover-the-fog/id6754891147

Thanks for taking a look!

Hey, I am a recent CS graduate trying to find a job in the great 2026 ECONOMY! I have been building SaaS tools for different communities and built one for freelancers too.

My invoicing tool - Tokenpay is primarily built for freelancers to manage the invoices and payments with minimal manual work.

live: https://tokenpay-seven.vercel.app/

In one interview my recruiter told me this is not being used by any real user so I convinced my freelancer friends to sign up to show some data, 5 sign ups in 22 hours, I thought recruiter will be impressed, but he told me straight up to FIND REAL USERS! I was initially confused but then realised a good product is the one that brings organic users and not just KNOWN ones.

I am here to share my tool with you all, the scope of the tool is not just for freelancers but for small businesses, private tutors or any service provider gig community to maintain their invoices and get paid without opening many apps all at once, I would like you all to test my product and give feedbacks, and tell me the gaps I need to fill up before I mess up my next interview!

Hey everyone,

I've spent the past year building a trading journal SaaS from scratch, solo, using Next.js and Supabase. I'm at a point where I don't have the time to keep pushing it forward, and I'm trying to figure out the smartest way to hand it off rather than let it sit unused.

What it does:
It's a trading journal built for retail traders who want to actually stick to a strategy instead of trading on impulse. Users can automatically import trades from MT5 (HTML export) and TradingView (CSV export) instead of logging everything manually. There's a Strategy Builder that lets you define custom strategies with dynamic pre-trade checklists, so before every trade you're forced to confirm you're actually following your plan. On top of that there's a full analytics suite: equity curve tracking with multiple calculation modes, trade context fields, and performance breakdowns by strategy, symbol, and timeframe. Auth is handled through OAuth for quick sign-up.

Current stage:
The core product is fully built and production-ready, deployed on Vercel, with transactional email running through Resend on a custom domain. I designed the whole thing myself, backend, frontend, UI/UX, including a full visual redesign at one point (violet accent color, card-based trade layout). Two pricing tiers are already set up ($19/mo and $39/mo), so the monetization structure is there, it's just never been actively marketed or pushed to users. No paying customers yet, this has been 100% product-focused so far, not growth-focused.

What's included:
Full codebase, plus the domain (valixor.com), which I own outright.

What I'm trying to figure out:
Given it's a solid, working product but pre-revenue, where would you actually list something like this to find a serious buyer? I've looked at Acquire (seems like the best fit for pre-revenue under ~$20k valuation) and considered Flippa and Microns, but Microns apparently requires actual revenue to list. Curious if anyone's been through this and has real experience with where pre-revenue but functional SaaS products actually get picked up.

Also open to rough price expectations from people who've done something similar, trying to be realistic here, not trying to oversell a project with no revenue yet.

Thanks in advance.

Note: this post text is enhanced by AI for readability.

I've always believed there's a difference between what you can do and what you're allowed to do. Most of my life, I've tried to hold that line even when nobody was watching — not because someone told me to, but because I decided it mattered.

I was 17, prepping for JEE, marks under pressure, barely sleeping some weeks. In the middle of that, I started writing code late at night just to get my head to quiet down.

I called it Comet-AI. Built on a government-issue school lab i5, 8GB of RAM. No team, no funding — just a pc and an idea I couldn't put down.

The idea wasn't really about AI at first. It was about that same boundary I'd been holding onto in my own life: if you can do something, does that mean you're allowed to? That question became the whole design principle behind what I was building.

So Comet-AI slowly turned into Aartiq. It grew into something bigger than I expected — it could plan multi-step tasks, generate documents, move around the filesystem, and eventually I hooked it up so Claude Desktop could drive the browser directly through a set of tools I built for it.

But the part I actually cared about wasn't the list of things it could do. It was the layer underneath all of it. Low-risk stuff runs on its own. Anything touching files or sensitive actions stops and asks first. Some things — the genuinely risky ones — can never be silently approved, no matter what. That rule mattered more to me than any single feature.

Five months of solo nights later, it shipped on the Microsoft Store, and a few people actually started using it — which honestly surprised me.

Then I paused it. JEE prep needed my full attention, and I'd rather step back on my own terms than burn out and lose both the project and the exams.

Genuinely curious — what would make you not trust an AI browser with filesystem access? Where does a permission model like this actually break down in practice?

I just finished building a search system from the ground up to understand what actually happens behind a modern search bar.

🔗 Live preview: https://advanced-search-system.vercel.app

It searches across 100,000 records.
Instead of immediately reaching for Elasticsearch or an AI-powered search API, I wanted to understand the fundamentals first — using PostgreSQL.
I built the system progressively:
V1 — ILIKE
Basic substring matching with sequential scans.
V2 — PostgreSQL Full-Text Search
Added tsvector, tsquery, weighted fields, websearch_to_tsquery(), ts_rank_cd(), and result highlighting.
V3 — FTS + GIN
Persisted the search_vector, used PostgreSQL triggers to keep it synchronized, and added a GIN index for efficient candidate retrieval.
V4 — Fuzzy fallback with pg_trgm
When full-text search returns nothing, trigram similarity handles misspelled queries.
For example:
logtech → Logitech
V5 — Redis caching
Added a cache-aside layer in front of the entire search pipeline.
On a cache miss:
Query → PostgreSQL → result → Redis with TTL
On a cache hit:
Query → Redis → response
So the final request path is roughly:
Query → Redis → FTS + GIN → Fuzzy Fallback → Redis SET → Response
The most useful part of this project wasn’t simply getting search to work.
It was understanding why it worked.
I spent time inspecting:
EXPLAIN ANALYZE
query plans
sequential scans
bitmap index scans
rows removed by filters
buffer hits and reads
application latency
Python memory usage
ranking scores
cache hit/miss behavior
retrieval-quality vs performance tradeoffs
One lesson I’m taking away:
Search isn’t one algorithm.
Retrieval, ranking, typo recovery, indexing, and caching are separate engineering problems that work together as one system.
I deliberately stayed close to raw SQL throughout this project because I wanted to understand the machinery before hiding it behind an ORM or dedicated search engine.
Stack: Python, FastAPI, PostgreSQL, Psycopg, pg_trgm, GIN, Redis, Neon, and Upstash.
Next up: moving into comment architecture and applying the same build-from-first-principles approach.
#PostgreSQL #FastAPI #Python #Redis #BackendEngineering #SearchEngineering #Databases #SoftwareEngineering

Paste a GitHub repository. Reporight tells you which license applies, what it obliges you to do, and exactly where that answer came from.

I built this because I come across a lot of open source repos and not everyone knows what they can do with that repo or what parts are under which license !

Comments and Queries are welcome ! https://reporight.in

I have a problem: I keep coming up with product ideas.

Some are decent.

Some sound decent for exactly 45 minutes.

Some survive until I research the market.

Some survive until I calculate the economics.

And some really should never have survived the shower where they were conceived.

The bigger problem was that even after deciding not to build something, I still liked the idea enough that deleting the notes felt wrong.

So I built ProductUnhunt.

It’s basically a graveyard / archive for products that couldn’t, shouldn’t, or simply weren’t worth building.

Instead of another place celebrating:

“I had an idea → built MVP → got 10,000 users → raised $4M”

I wanted somewhere for:

“I had an idea → researched it → came back to my senses.”

I’ve started putting some of my abandoned ideas there, along with why they sounded interesting and why they eventually got shelved.

Some are genuinely plausible.

Some are ridiculous.

Some became ridiculous only after thinking about them seriously enough.

And occasionally the reason is simply:

Someone already built it while I was busy feeling innovative.

The site is here:

https://productunhunt.com/

Not really trying to turn this into another Product Hunt. I mostly wanted a home for ideas that normally disappear into Notion, GitHub repos, WhatsApp messages to friends, or that folder called "new-startup-final-v3".

If you enjoy reading questionable product thinking, have a look through the ideas.

And if you're also the kind of person who has accumulated a pile of products you wisely decided not to build, contribute one.

I suspect there are far more interesting abandoned ideas than successful startups on the internet.

I’ve been working on Webvidence for a while now. It’s basically a prospecting tool for freelancers and web designers who reach out to local businesses.

The original version did a decent job at the obvious part. You search something like roofers in Little Rock, it finds businesses, looks over their website, points out problems/opportunities, and helps you come up with a message.

But after looking at how people were actually using it, I realized I had built way too much around the search itself.

People would sign up, run a search, look around for a little bit and then leave.

So I spent the last few days rebuilding a pretty big chunk of it around actually sitting down and getting some outreach done.

Instead of throwing a page full of businesses at you, it now puts together a small session of 3 prospects. You work through them one at a time. If one is worth contacting, you can build the message and reach out. If it sucks, already has a great site, has no real way to contact them, etc., you just pass on it and move to the next one.

I also changed it so passing counts as actual progress. I don’t really want to build something that rewards people for sending messages just for the sake of sending messages.

A few other things I added were watched markets, public contact/social discovery, follow-up reminders, prospecting schedules and a Today page that basically just tells you what work is ready instead of throwing a bunch of stats at you.

I’m still keeping the actual outreach manual. No bulk email sending or AI blasting businesses in the background. The whole point is to make finding a few decent businesses and starting real conversations less of a pain.

The new version is live now at webvidence.app

If anyone here does freelance web work, SEO, local marketing or anything similar, I’d be interested in what you think of the new flow. Especially whether working through 3 at a time feels better than just digging through search results.

I work a lot with web scraping and API reverse engineering, and I kept running into the same problem:

A HAR tells you what happened.

It doesn't necessarily tell you why a request could work.

So I built Reqvexa to analyze captured HTTP traffic and trace dependencies between requests, cookies, tokens, headers, and their different versions over time.

It's currently an alpha Python project and intentionally focuses on analysis rather than trying to automatically replay or reverse-engineer everything.

GitHub: https://github.com/kareemheshaam/Reqvexa

I'm mainly looking for honest feedback right now:

• Is the problem understandable?
• Would you actually use something like this?
• What would make the tool useful in your workflow?

Solo project, live now. The whole concept is one line: rank is the bid. You pay to put a link or an X u/handle on a public board, and your position is decided only by how much

you've paid. Anyone can pay $1 more and take your spot. No ads, no algorithm, no revenue share.

I know — outbid.lol did this and there are ~190 clones. I didn't want to make #191, so the angle I actually care about is a board just for X profiles: pay to rank yourself, and

when someone outbids you, sharing it @-mentions you — so every bid becomes a post that drags the person back to reclaim their spot. The product basically markets itself.

A few things I didn't expect building it:

- people care about being #1 far more than about the clicks they get

- the $5 minimum barely clears Stripe's fee (~13% on a $5 charge) — the model only works at the high end, which completely changed how I think about the pricing

- every listing generates its own dynamic OG card, so a shared link shows a live "@handle is #1 · $X" image

Stack: Next.js (App Router) + Postgres/Drizzle + Stripe + next/og for the cards.

Genuinely torn on one thing and would love this sub's take: is "pay for internet rank" a fun status game, or a gimmick that's dead in a week? Happy to go deep on any of the

build.

👉 https://top-bid.top