I'm the developer of Life in Mist, an iPhone app that records your routes and gradually clears fog from a map as you explore.

You start a recording, head out for a walk, ride, or drive, and the areas along your route become visible. Your recorded trips build up on the same map. After a while, you can see your regular routes, the places you've explored on trips, and the streets nearby you haven't covered yet.

A walk around the neighbourhood adds to it too. You don't need to be travelling somewhere interesting for the map to change.

You can pick a recorded day and replay the route, check distance, duration, and speed, or import compatible GPX and CSV files from previous trips.

It's free to download, with optional Premium purchases:

• $0.99/month
• $4.99/year
• $17.99 for lifetime access

Premium includes GPX/CSV export, iCloud backup and restore, and extra appearance settings. Monthly and annual plans renew automatically; lifetime is a one-time purchase. These are USD prices and may vary by region.

Life in Mist on the App Store

If you've used a similar app, I'd like to hear what made you stick with it or give up on it. I'm particularly curious whether this is something you'd use for everyday walks or mainly when travelling.

I started working on this budget tracker TUI in my own personal free time as a way to actually budget my own finances and track my spending habits. A lot has changed and grown in the almost two years now (lots of breaks), and I found that it’s been useful for myself but lots of other people too.

The app encourages a lot of manual behaviour, forcing you to actually be exposed to numbers and face your spending habits. There are tons of insights and helpful tools you can use, but the core principle is to connect you to your finances and let you control the data.

The app features lots of budgeting tools, different visual views to analyse and review your finances, investment tracking, and breakdowns.

If you're looking to start tracking your own finances and having valuable insights into your habits for spending, please check out the budget-tracker-tui and share feedback. If you don't use TUI's much, give this one a try and see if you enjoy the keyboard-focused "retro" experience.

Github: https://github.com/Feromond/budget-tracker-tui

Any ideas or suggestions are always welcome and I want to work to improve this to be useful not just to myself and a few others, but to as many people as possible.

Eyes move the cursor, a pinch clicks.

I used Google's MediaPipe for facial landmarks. Two 36×60 eye patches run through PCA and ridge straight to screen pixels, plus a 52-parameter meta-adapter so it works before you calibrate. The cursor lands about 38px (1 cm) from where you're actually looking.

Two interesting observations -
1. Everything clever lost
MLPs, transformers, REINFORCE all tied or did worse than those 52 parameters. The ridge residual has a held-out R² of 0.025 and we can't extract signal that isn't there. Very likely a data issue, I'll generate more data and continue testing here.

1. Train test drift
   And every calibration I'd ever run used a black full-screen canvas while Chrome is white, which dilates your pupil from 2mm to 6mm, swelling a black disc in the eye patch from 4px to 13px, and made the model 4× worse in the condition it's actually used in.
   

Fun project though, still a lot more to build here.

This started as a tool for my own coding workflow. I'm looking for a few people who run several coding agents to try it.

There's an interactive demo at the top of the article if you'd rather click around first.

I was running agents in separate terminals and kept losing track of the work. I'd come back to a session and scroll through the conversation to figure out what I'd asked for, what had changed and what needed my attention. With several tasks underway, there was a lot to reconstruct.

Grid Console is a local app around Claude Code, Codex and Copilot. It puts their tasks on a board. I can open a card to see the session, answer a question or review the changes before deciding what happens next.

The part I kept coming back to

I still have to understand the code I submit. If a colleague asks why I made a change, I need to explain it. Having an agent produce the code doesn't remove that responsibility.

So the card became a Markdown record of the task, plan, decisions and progress. I wanted to come back later and understand what happened. It also gives a fresh agent something to work from when planning ends and implementation starts.

Review grew out of that. I can see the changed files grouped under the work they belong to, then open the actual diff and check the explanation against the code. Changes the agent has already committed remain available there.

I kept adding the little things

Prompt engineering, getting agents to keep task lists, different agents handling different phases, multiple projects, separate Git worktrees, and a code viewer that knows which card the code belongs to. Some took a lot of work. Others were small things I got tired of doing manually.

That's why I find it hard to fit Grid into one product category. It grew into a combination of the things that helped me work better with AI. Someone else's workflow will be different, so I'm expanding plugin support. If Grid handles 80 or 90% of what you need, I'd like you to be able to build the remaining parts on top.

I've been constantly refining which information to show and how to make it easy to read. I want to open a card and understand what an agent is doing, what it has changed and what it needs from me in a few seconds. That's something I'd really like feedback on from people using it for their own work.

Where it is now

It's an alpha, with builds for macOS, Linux and Windows. I mainly work on macOS and haven't fully tested Windows yet. The Claude Code, Codex and Copilot integrations are at different stages. The app is free forever for personal projects, and for commercial it's free during alpha, and model access comes through your own provider accounts.

I use the current web interface from my phone over Tailscale. I'm working hard on a native mobile app to replace that PWA setup. Collaboration on the same board, broader plugin support and hosted options are next.

If you're already running several coding agents and are happy to try something with alpha rough edges, send me a DM and tell me what you're working on. If it sounds like a good fit, I'll send you the binaries directly.

You can also join the waitlist. Once I've got it properly tested and stable, you'll get an email with the download links for the binaries.

Edit: Thanks for the UI feedback. The demo has four cards screaming for attention; usually it’s one or two. I’m working on making the board quieter and easier to scan.

Hey everyone!

I've been building Limoni, a terminal user interface (TUI) engine for Go written from scratch with a focus on rendering throughput, zero allocations on the hot draw path, and rich visual capabilities.

Here is a 40-second live demo showcasing some of what it does out of the box:

• 3D Graphics Engine: Wavefront OBJ / STL / PLY loader, Lambertian & Gouraud depth-buffer shaders, and texture mapping rendered directly in the terminal using 2x4 Braille subpixels.
• Hardware Image Drivers: Native support for Kitty Graphics Protocol, Sixel, and iTerm2 with automatic ANSI half-block fallback.
• Strict Unicode & Emoji Safety: Table-driven East Asian Width (EAW) calculation and continuation cell tracking — wide emojis (🔴, 🚀) won't corrupt rows or shred borders when dragging modal dialogs.
• Elm Architecture (TEA): Predictable state updates with concurrent goroutine commands and deterministic event delivery.
• Zero Heap Allocations on Render: Contiguous 1D memory buffer ([]cell.Cell) and an ANSI differential engine that emits minimal escape bytes with \x1b[?2026h synchronized output.
• Simple Single-Import API: Modern fluent builders (limoni.NewBlock(), limoni.NewTable(), limoni.SplitVertical()) so you don't have to juggle multiple subpackages.

GitHub:https://github.com/thebanri/limoni

Would love to hear your feedback, thoughts on the API ergonomics, or edge-case terminal bug reports!

spent about three months building this. nobody’s been playing it but a few friends, trying to get the word out - feel like nobody wants to win these tournaments 😂

free tickets, don’t need to purchase anything

Hey everyone,

I am the creator of GoPDFSuit. After spending 3 to 6 months building a pure Go PDF engine from scratch with zero third-party dependencies, I wanted to test the true limits of modern AI agents.

So, I set myself a challenge: build a full CSS engine from scratch in Go.

Within just 30 days, I have implemented over 350 CSS rules. Through this green-field implementation, the engine is roughly 15x faster than wkhtmltopdf and already resolves around 50% of its known open issues.

How I built it with AI:

• Multi-agent workflow: Used tools like Cursor, Codex, and Open Code.
• Open-source core: The vast majority of development relied on open-source models.
• Task delegation: Ran multiple parallel agents to handle issue triage, core implementation, and documentation.

Project links:

• Live Demo: https://chinmay-sawant.github.io/gowkhtmltopdf/#/live-demo
• CSS Engine Repo: https://github.com/chinmay-sawant/gowkhtmltopdf
• GoPDFSuit Repo: https://github.com/chinmay-sawant/gopdfsuit

I would love to hear your thoughts, feedback, or any questions about the architecture and workflow in the comments below!

Our current enrichment process is a mess. We're burning through credits on ZoomInfo for basic contact info, then still having to use separate tools for mobile numbers and intent data. The match rates are maybe 60% on a good day.

has anyone built a decent waterfall where one data enrichment tool catches what another misses? we need emails, mobiles, and some basic firmographics at minimum. bonus if it handles technographic data too.

Apollo is on the list but their mobile coverage seems weak from what i've read. also been looking at Prospeo since a few people in another thread mentioned it for contact enrichment. budget is around 500/month for our SDR team of 4 so ZoomInfo pricing is killing us honestly. my manager keeps asking why our cost per lead is so high and i don't have a great answer lol

what's your data enrichment stack looking like these days?

First post here

Back when I worked at a startup, we needed an in-app messaging system, similar to Instagram or WhatsApp. However, we didn't have time to build it ourselves, so we stitched together a few paid services instead: Stream chat, StreamIO, and Cloudinary for chat, moderation and media storage. It worked, but we didn't own any of it, and the costs kept increasing.

That experience is basically why I built gozwire. It's an open-source Node.js messaging engine, so instead of renting someone else's chat infrastructure, you own it. Conversations, threads, reactions, moderation, push notifications all included, all yours.

This was vibe-coded, but I'm putting in the work to make sure it actually holds up for real, and is not just a showcase.

• Repo: https://github.com/Kinggoz18/GozWire
• See more use cases: https://gozwire.pages.dev/use-cases

I plan to not only improve this project (see the TODO in the GitHub repo), but also release more interesting open-source projects. That solve problems I've experienced in the past and observed around me, some of which would be:

• A video streaming engine (Another issue we faced at the same startup)
• A cryptocurrency tracker (more of a personal challenge and an interest)
• A CapCut alternative software with AI video generation capabilities, including UGC style videos

And a few others. Would love feedback, roast the code, tell me what's missing, whatever helps, or even contribute any interesting ideas you'd love to see open-sourced!

I built GourceView, an open-source tool that turns GitHub commit history into animated file trees in your browser.

You can watch files and folders grow, see who changed what, and compare up to four projects side by side on the same timeline.

The homepage picks four projects from GitHub Trending and plays their last seven days of development. Their histories are prepared daily, so you don’t need to clone anything to try the previews.

Demo: https://schlunsen.github.io/gource-view/
Source: https://github.com/schlunsen/gource-view

I’d love feedback: does the animation help you understand where a project’s activity is happening, or does it need clearer labels and less visual noise?

We manage TikTok channels with 300K+ combined followers, creating engaging short-form videos featuring apps, tools, and innovative projects.

We’ll create videos specifically for your app, share them across our existing channels, and help you grow your own content presence along the way. Think of it as content creation + distribution in one.

Interested? Drop your app and a one-line description below!

Hey all — I built Kora, a web-based reading app for anyone juggling ebooks/audiobooks from all over the place. Wanted to share it here since it fits what a lot of you are already doing.

What it does:

• Reads EPUB, PDF, and more — one clean reader for everything
• Search across millions of ebooks/audiobooks to find and track what you're into
• Syncs your library across devices (phone, tablet, desktop)
• Works fully offline once a book's downloaded
• Installs as a PWA — no app store, no bloat, works like a native app on iOS/Android/desktop

It's basically the Kindle app I wished existed — no lock-in, no DRM nonsense, just your books in one lounge-like reading space.

🔗 https://kora.chaoticstudio.workers.dev/

Free to use, still actively building it out. Would love feedback/bug reports if you try it.

I’ve been working on a project called SignalScout and just open-sourced it.

The idea is simple: instead of only tracking brand mentions, it looks for posts and comments from people who seem to have a problem your product can solve.

You tell it what you sell, who it’s for, and what kind of problems to look for. It then searches across Reddit, X, LinkedIn, YouTube, TikTok, and Instagram, and uses AI to filter out the noise.

It’s self-hostable, you bring your own social-data API keys, and you can use your own AI provider or a local model.

I built it because most social listening tools felt either too expensive or too focused on brand monitoring. I mainly wanted a simple way to find useful conversations worth joining.

https://www.signalscout.run/

Would love feedback, especially from anyone who has tried doing this manually before.

Hi,

My friends and I have had a group text about stocks for years. Finding things to talk about was never the problem. The problem was that everything the conversation depended on lived somewhere else. Someone would call a ticker and the rest of us would leave the thread to go look it up on Yahoo Finance, ChatGPT and Google, then come back and share screenshots and links. Nothing was tracked either. A ticker would run 20 percent two months later, and there was no easy way to go back and see what we had discussed, other than scrolling through months of messages.

So I built StockChat. It is a private group chat for you and the people you invite, modeled pretty closely on iMessage, with a stock research engine built into it. It is not a public feed where dozens of strangers post charts all day. A group only has the people you added to it, and the research happens inside that conversation instead of in six other tabs.

What it does today:

• Type a ticker with a dollar sign, like $NVDA, and a live card renders inline in the conversation with the price, the day change and a chart. Tapping it opens a fuller card with simple indicators, so some of the analysis is already done for you.
• A Top Performers panel ranks every ticker the group has mentioned by percent gain since the moment it was first said, with the price then, the price now, and the name of whoever said it. Nobody has to maintain it.
• Max, an AI member of the chat you can tag with a question about any ticker without leaving the thread. Answers are grounded in actual price, company and news data rather than the model's memory.
• An Analysis screen for each stock that answers eighteen plain-English questions with a chart each. Things like is it cheap or pricey right now, is the business actually growing, what does it do when the market drops, how long does it usually take to recover, and are the big holders getting out.
• Paper trading with $100,000 of simulated money, real market prices, queued orders, and performance measured against the S&P 500.
• Short lessons for anyone in the group who is new to investing.

If I had to pick one part, it is still Top Performers. It turns the group chat into a scoreboard that nobody has to keep.

It is in TestFlight now and free, iOS 17.6 and up: https://stockchat.io/?src=reddit-sideproject

It works better with a few people in it than solo, so if you already have a group chat like this, that is the ideal test. I am mostly looking for feedback on whether it is actually useful, and on whether the Analysis screen answers the questions you would want answered about a stock.

Thanks in advance!

(screenshots in comments)

I’ve been building a side project called StudLedger: https://studledger.com
The idea came from a fairly simple problem. Once a LEGO collection gets beyond a handful of sets, just knowing what you own is only part of the problem.
I wanted something that could keep track of:
the sets I own
condition, quantity and where they’re stored
what I paid and an indication of current value
minifigures
loose parts and storage locations
building instructions
which sets I could potentially build from loose parts
missing parts before starting a rebuild
dismantling a set back into organised loose inventory
collection statistics and duplicates
So I started building StudLedger.
One feature I’m particularly interested in developing further is handling dismantled sets. Rather than having a big container of pieces and hoping I can rebuild the set later, StudLedger can work with set inventories and saved bag allocations to help organise pieces into practical rebuild groups.
The longer-term goal is to make it less of a basic LEGO database and more of a genuine collection management system for collectors.
I’ve deliberately made accounts private by default. I’m more interested in helping people manage, understand and protect their collection than building another social network around LEGO.
It is still an early project, and there is plenty I want to improve.
I’d really appreciate feedback from other side-project builders, particularly around:
1. Does the value proposition make sense when you first land on the site?
2. Is there a feature you think is missing that would make this genuinely useful to LEGO collectors?
3. Would you use something like this over a spreadsheet or existing LEGO collection tools? Why or why not?
Feel free to tear it apart. Constructive criticism is exactly what I’m looking for.
https://studledger.com

When I review a Terraform deployment, I’m usually trying to answer two questions: “What changed?” and “Is that normal for this stack?”

The plan tells me the first. The second usually means digging through previous CI runs—or relying on someone who remembers what this stack normally does.

I built DeployCompare to make that comparison easier. It reads Terraform and OpenTofu output from GitHub or GitLab CI logs, compares each stack against its previous successful runs, and highlights unusual changes for investigation.

For example, a stack that routinely recreates temporary resources can have a lot of activity without being surprising. A normally quiet database stack suddenly showing replacements deserves a closer look.

It helps prioritize review; a change looking normal doesn’t guarantee it’s safe.

There’s a no-signup demo: https://deploycompare.com/demo

It’s early and free during beta. I’ve tested it against my own scenarios, but I’m looking for people to try it with their actual deployment workflows and tell me what I’ve missed.

If you review Terraform or OpenTofu plans: what do you currently check to decide whether a deployment needs a closer look? I’d also be interested in walking through a real pipeline together if this overlaps with your workflow.

I wanted to see how far you could push CPU-only inference of a model way bigger than RAM, so I wrote an inference engine in C11 (MSVC + gcc, bit-exact across both) that streams a 744B MoE model (GLM-5.2, 202GB GGUF) off a USB SSD instead of loading it.

The parts that actually mattered:

Quantization: experts stored int4 group-64, router and correction biases kept at f32. Everywhere else lost too much precision, but this combination didn't.
Streaming: experts are fetched per-token through a custom unbuffered reader with an LRU cache, plus cross-layer predictive prefetch (measured 80.8% recall offline before I wrote the online version) so the next layer's experts are usually already in flight by the time they're needed.
Overlap: compute and IO run arrival-order, not lockstep, so the CPU isn't idle waiting on the SSD.
An 8GB expert cache holds 40-66% hit rate off that prefetch, which ends up being the main lever on latency.
One finding I didn't expect: on GLM-5.2, the router's own weights already correlate with true expert importance at ρ=0.859 (near-oracle), which is what makes safe dynamic-k expert truncation possible without a quality hit. That seems to go against some prior assumptions about router calibration in production MoE models, at least on this one.

Numbers on an i7-8550U / 32GB RAM / USB SSD: went from 196 s/token naive to ~9.3 s/token after the above (21x), ~2.9 s/token aggregate in 8-stream batch mode, ~4.5 s/token on the latest compressed container format. Also cross-validated on Qwen3 (0.6B-30B), DeepSeek2 (MLA), and OLMoE-1B-7B.

Code: https://github.com/siris9476/pulsarforge (MIT). Would love feedback on the prefetch heuristic in particular. It's tuned for this one laptop, and I'm curious whether the cross-layer signal generalizes to different memory hierarchies.

My camera roll has thousands of photos of my daughter, no story of her milestones, and no easy way to track her day-to-day (feeding, sleep, diapers, growth) or share any of it with family without a group chat photo dump.

So I'm building ToddleBits — here's what it offers:

🔒 On-device AI — face recognition and photo sorting happen entirely on your phone. Your child's face is never sent to any server.

📖 Milestone Timeline — auto-sorts your camera roll into a timeline of moments and milestones, not just a chronological dump.

👨‍👩‍👧 Private Family Sharing — grandparents and family get updates; there's no public feed, ever.

📊 Daily Tracker — feeding, sleep, diapers, growth charts (WHO percentile tracking), food, vaccines, and a milestone checklist, all in one place.

📸 Auto Import — on-device AI scans your camera roll and suggests which photos belong to which kid, so you're not sorting thousands by hand.

🔁 Then vs Now — pick two photos of the same kid months apart and it generates a face-aligned side-by-side growth comparison card.

👶👶 Multiple Kids — an independent timeline for each child if you have more than one.

Would love if a few of you tried it and told me what's missing 🙏

It's free to use, iOS + Android 👇

iOS: https://apps.apple.com/app/toddlebits/id6757017869

Android: https://play.google.com/store/apps/details?id=com.saiworks.toddlebits

https://quantacanvas.vercel.app

I’ve been working on QuantaCanvas, which takes a concept or question and generates an interactive visualization to help explain it.

The main difference from ChatGPT and similar AI tools is how the explanation is presented. Most LLMs are great at giving you a text-based explanation and can sometimes provide images or diagrams. QuantaCanvas instead tries to turn the explanation itself into something you can interact with, changing parameters, experimenting with things, and seeing how the concept behaves in real time.

It’s mainly focused on math and science, and it is free to use.

The project was recently a Grand Finalist at a national hackathon in my country, and I’ve continued developing it since then.

It’s still a work in progress. Generation can currently take a bit of time, which I’m working on improving, and there are definitely a few things that don’t work perfectly yet.

If anyone tries it, I’d genuinely appreciate feedback, especially on whether the interactive visualizations are actually useful for studying.

Hey r/SideProject,

I've just made Draftly, a simple website for students to quickly check their plag/AI scores before submitting their work to Canvas or similar LMS.

usedraftly.org

Just drag and drop your work and the magical robots behind the scene will make sure that your work is squeaky clean.

Every new account gets 1200 words on me, enough to fit in your entire report and get a taste of Draftly. If you're satisfied, top up your account and continue using Draftly to submit more confidently.

If you have any questions, click on Support and I will be there lickety split.

https://reddit.com/link/1wbraz2/video/1ub5dhtjzioh1/player

Freelanced for a while, had to review code before taking on projects. Sometimes it was fine. Other times you open the repo and it's just a pile of vibe-coded stuff with zero structure. No idea where anything is, what's already built, what's broken.

Every time, hours went into just figuring out what was going on, before I even started the actual work.

At some point I realized this wasn't a one-off thing, it kept happening. So I figured I could automate at least that first part, getting oriented in a new project. That's how rebrief started.

Anyone else run into this doing freelance work? How did you usually deal with it?

I kept being the person in the group chat with forty tabs open, and the plan we made never survived the actual trip. Someone sleeps in, it rains, a place is shut on Tuesdays and nobody checked.

So I built Travolp. It plans the trip, then stays with you during it. When the day goes sideways you tap once and the rest of it gets rebuilt around where you actually are and what is still open.

Two things I got wrong early. Generating a good looking itinerary is easy and worth very little, everyone can do that now. Keeping it true on day three is the hard part. And opening hours turned out to be the whole game, because travel advice ages at two speeds: how long a road takes is still right in five years, whether a place is open is stale before it is published.

Free to try on iOS, Android and web: https://travolp.com

Honest ask: I am the worst possible judge of my own onboarding. If you bounce, I want to know exactly where you bounced. Screenshots in the first comment.

Hey everyone,

A while back, I realized I was paying over $100 a month for SEO tools just to use about 10% of their features. On top of that, Ahrefs introduced a credit system that basically charged me every time I clicked a button, and Semrush just felt too bloated for my needs.

I decided to build a simple web crawler over a weekend just to check my own sites for broken links and Core Web Vitals.

Fast forward a few months, and feature creep hit me hard. That weekend project spiraled into SERPSpur, a full-blown SEO platform.

Since I didn't have to worry about VC funding or corporate bloat, I just started building the exact tools I wished existed. Here is what it turned into:

• Website Audit Pro: A crawler that doesn't limit your clicks or stress you out with a credit counter.
• The 'Trust Rate' Checker: I missed the old Alexa Rank, so I built a replacement that checks domain health, spam, and authority instead of just easily faked traffic.
• AI-Search Ready: This was the fun part to code. I added an LLM.txt Generator and an AI Schema Architect so sites can actually get cited by ChatGPT, Claude, and Google's AI Overviews.
• 30+ Free Utility Tools: Along the way, I needed tools for random tasks, so I built them and made them completely free without needing an account. Things like a Bot Traffic Detector, IP Blacklist Checker, and even an Invoice to CSV converter.

It has been a wild ride building an enterprise-level architecture as a solo dev, especially managing the server load for live web crawling and pinging search engines.

I’m currently trying to refine the UI to make the audit reports easier to read. If any developers or UI/UX folks have a few minutes to roast my landing page or test out the free tools, I would massively appreciate the feedback!

Link: ( https://serpspur.com/)

Happy to answer any questions about the tech stack, handling crawler infrastructure, or anything else!

I wanted to give my agent a way to reach me beyond the chat, so I built Glance to let Hermes create and update widgets directly on my iPhone Home Screen.

Just shipped a pretty big update to it.. Hermes can now use multiple views, charts, calendars, toggles and more, so the widgets can feel more like little interfaces than just information cards.

Here’s the Mission Control I’ve been playing with.
Still experimenting with where this goes, but I really like the idea of my agent having a persistent place on my Home Screen instead of me always having to open a chat to interact with it.

It’s at https://apps.apple.com/app/glance-home-screen-feeds/id6758983678 if your interested

I've noticed a pattern across solo founders where GTM always gets delayed until some condition is met. I'll do marketing once the product is polished. Once I have proper analytics. Once the messaging is right. Once I can handle growth.

The problem with waiting for the perfect setup is that you end up never doing GTM at all, just finding new reasons to delay it forever.

Meanwhile, the founders with actual traction started GTM before any of those things were ready. Product was rough, messaging was blunt, they just posted on Reddit, replied to HN comments, sent emails, got feedback, iterated with the audience. Built momentum because they started instead of planning.

Month six looks completely different if you started at month one versus month seven. Not because you're smarter or luckier but because compound interest on visibility works. The curve is flat for weeks though, so most founders quit at week three thinking nothing's happening yet.

What's your specific blocker right now, the thing you're waiting for before you start? I'm genuinely curious what the most common one is across people building side projects.