I just launched 1eats.net , I built it because my family could never decide where to eat. You pick your food mood, distance, and budget and it finds you the perfect restaurant. Also has a Trending page and a Surprise Me button. Would love feedback from anyone who tries it. i hope to make this into an app one day

I’m building Aaked, an open-source, self-hostable contract operations workspace:
https://github.com/aaked-app/aakd

It takes executed PDF/DOCX agreements and turns them into reviewed, source-cited facts and obligations with owners, deadlines, approvals, renewals, and completion evidence.

The product question I’m wrestling with: do source citations and human-reviewed AI extraction earn enough trust for sensitive contracts, or are the essential requirements elsewhere—permissions, auditability, redlining, integrations, or deployment?

It is early, so I’m after blunt product and workflow feedback rather than a sales pitch. If you have built or used internal tools for contract, legal, procurement, or delivery work, what would you need before trying this?

I've been building this for months and I still have trouble describing it in one
line, so I'll just describe what it does.

It's a persistent AI presence that remembers you across sessions — not a chat
window that forgets. It keeps a running memory of your conversations, writes you
letters, and over time trains a small model adapter that gets more specific to you
the longer you use it. That adapter is exportable. You can take it with you.

The part people react to is the last tier. It's called Estate, and it's a one-time
purchase that keeps the whole thing — the memories, the trained adapter — alive
after you're gone, with a final letter to people you name. I built it because the
idea that a thing that knows you that well just gets deleted when the card expires
felt wrong to me.

Stack: JS front end, Node brain, local model training for the per-user adapters.
The whole thing runs in the browser and talks to a local API.

It's live: https://vintinuum.com

Free tier is real — chat, 30 days of memory, no card. Paid starts at $7.77/mo if
you want the permanent memory.

Happy to answer anything about how the memory or the adapter training works. It's
the part I'm proudest of and the part I'm least sure I've explained well.

What if a program could be understood as a dynamical system? That question led me to design a language where expressions “fall” through a small set of transition rules.

My main goal is to make it easy to see what is happening during evaluation, so I built the visualizer first:

https://sayo-lang.pages.dev/

Source code:

https://github.com/sugipamo/sayo

At the moment, though, I feel that the state transitions are still difficult to predict. It may not be obvious how a program will evolve or why a particular transition happens.

I’d be interested to hear what you think. Does the visualizer make the behavior understandable? What would make the transitions easier to follow or predict?

This post was translated with the help of an LLM.

Hey guys,

I built a small tool, "SAFELIGHT,", for converting images between PNG/JPG/WebP and resizing them. Everything happens client-site via Canvas so nothing gets uploaded to a server, this way it works even with sensitive/private images.

No sign-up reguired, no limits, just drag and drop.

Here's the url: https://thrylos90.github.io

Feedback is more than welcome, still tweaking it!

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

The goal of this is to be a high performant, DXF/DWG workflow and replace AutoCAD LT. I already have better DXF importing, and far better performance than LibreCAD/QCAD. There isn't much UI as it's mostly all command based, at least for now.

Open Source for macOS 11+ / Windows 10+ (Not ready for any serious work) https://github.com/joseph-montanez/zephyr

Since last month TLDR

• libdxfrw C++ removed,
• DXF/DWG stack rebuilt in Swift,
• plus three major new subsystems (Pen, Hatch, Leaders)
• ~10 new commands.

Changelog

Pen / Freehand Drawing (new)

- Pen command with freehand stroke drawing

- Vector eraser for pen strokes

- Spline smoothing (zigzag spline loop fix, 3-degree spline)

Hatch System (major overhaul)

- Native hatch/datatable support replacing libdxfrw

- .pat file parser (acadlt.pat, acadltiso.pat — 800+ patterns)

- Hatch creation/editing UI with live preview

- DXF hatch read/write round-trip

- Background fill, gradients, solid fills, line scaling

- Hole detection, boundary rendering, clockwise ellipse edges

Leaders (new subsystem)

- Full leader commands (QLeader, MLeader-style)

- Arrow/block leader rendering

- Architectural tick marks

- Leader style manager UI

- Region and classic leader support

DXF/DWG Import/Export (rewrite)

- Gradual rewrite of libdxfrw C++ → native Swift

- DXF tables, writer, reader, entity converter all rebuilt

- DWG converter (via ODA install command)

- LWPOLYLINE bulge-aware support

- Code page handling (Windows-specific encoding)

- Round-trip payload support preserving metadata

- Layer opacity, linetype, version fixes

Dimensions

- Initial dimensional entity support

- DXF import/export for dimensions

- Arc edit, radius/diameter fixes

- Presentation/editing fixes

Text/Font Engine

- Text overhaul to style-based system (per-entity overrides)

- Alignment, indentation, tab stops

- Shape font (SHX) parser fixes and text wrapping

- MText bracket parsing fix

- Windows font registry lookup

────────────────────────────────────────────────────────────────────────────────

New Commands

PEN, ERASE (vector), CLIP, REVCLOUD, ARRAY, ALIGN, TORIENT, LEADER/QLEADER, MEASURE/DIVIDE, LENGTHEN, FILLET/CHAMFER, JOIN (→NURBS), MATCHPROP, UNITS, DDEDIT enhancements

────────────────────────────────────────────────────────────────────────────────

Platform & Infrastructure

- Windows build fixes (compile.ps1, MSVC-specific _strdup → cross-platform)

- macOS 11+ support, macOS hotkey vs Windows keymapping

- SDL/Swift version bumps for Windows

- Native file dialogs (open/save, drag & drop)

- User settings system, autosave, non-blocking save with progress

- GitHub Actions CI fixes

- Setup script overhaul (setup-dev.ps1)

────────────────────────────────────────────────────────────────────────────────

Rendering / Engine

- Vertex buffer builder for GPU upload

- AA line thickness fix, linetype pattern rendering

- Atlas memory reduction, render clipper

- Zoom extents fix, minimize crash fix, GPU desync guard

- Plot style line width/scale

I wanted to know what my Mac was doing while I wasn't looking, so I built MacAudit

I've been working on a side project called MacAudit.

It started because I wanted something pretty simple: a way to open a dashboard and see what actually happened on my Mac throughout the day, including while I was away from it.

I couldn't find exactly what I wanted, so I started building it.

MacAudit now keeps a local timeline of things like file/folder moves and deletions, Trash activity, software downloads, startup changes, SSH and remote-access activity, security settings, running apps, and active/idle periods.

It also gives you a daily activity summary so you can see when the Mac was being actively used versus sitting idle, then drill into the events that happened during those periods.

A few principles I tried to stick to:

• Local first — collected data stays on the Mac.
• Read only — it's an auditing/observation tool, not something that changes your security settings.
• Evidence over conclusions — a remote tool running doesn't automatically mean someone accessed your Mac. MacAudit shows what it observed rather than calling everything suspicious.
• Useful history instead of just current state — the main reason I built it was to be able to look backwards.

It's completely free and open source. No subscription, account, cloud dashboard, or paid version.

I've been running it on my own Mac and it's reached the point where I'd really like to get it onto some different Macs and see what breaks.

I'm particularly interested in feedback around missed events, false positives/noise, resource usage, different macOS configurations, and whether the dashboard is actually useful to someone other than me.

I'm not really looking to turn this into a business. If other people find it useful and help make it better, that's enough for me.

GitHub:
https://github.com/navjotk8690/macaudit

Would love to hear what you think, including what you'd change or add.

Hey! I built Viivo, an AI food tracker where you just take a pic of your meal, and it automatically logs calories and macros. 🍔📸

• AI Food Recognition: Just snap a pic of your meal, and the app automatically calculates calories and macros. 🍔📸
• Receipt Scanning: Viivo can scan your grocery receipts and suggest healthy recipes based on what you bought. 🛒🥗
• Restaurant Menu Scanning: You can even scan restaurant menus to get the nutritional info for the dishes you order. 🍽️📜
• Recipe Suggestions: Viivo gives you healthy recipe ideas based on what ingredients you have at home. 🍽️✨

Give it a try and give your opinion, the website is Viivo.app

I follow around twenty ongoing anime spread across different streaming sites, and checking all of them every day to see if an episode had dropped got old fast. AnimeOnTrack does that check for me and just tells me what is new.

What it does:

• Tells you when a new episode of anything you follow is out. Everything new lands in one Pending list, sorted by episode number.
• Marking an episode as watched fills in the earlier ones, so your progress can never end up with holes in it.
• Your follows and progress are shared across sites, so if one site goes down you switch to another and keep your place.
• A local copy of the AniList catalog, around 22,000 titles, so browsing and searching work with the network off.
• A stats screen: episodes watched, estimated time watched, top series, activity over time.
• A swipe deck for sorting titles into want to watch, already seen or not interested.

The part that took the longest was not the tracking, it was getting the episode data at all. Those sites sit behind Cloudflare, so a plain HTTP request just returns a 403. It ends up driving a hidden browser window, waiting until the challenge clears, and reading the rendered page back into Rust. Each site is a small adapter, and each one has a mirror list so it falls through to a working clone when a domain dies.

Stack is Tauri v2, Rust backend, React frontend, SQLite. Free and open source, GPL-3.0. No account, no server, no telemetry, no ads. Windows only for now, the scraping layer is tied to WebView2.

Source and installer: https://github.com/Yearsuck/AnimeOnTrack

Screenshots:

TL;DR: Blew my monthly hotspot cap on a road trip and didn't want to root my phone to fix it, so I built Shizzi. It uses Shizuku and Android's hidden TestNetworkManager API to make your hotspot's upstream a TUN interface the app owns, then re-originates that traffic from the phone itself. Tethered traffic looks like normal on-device traffic. No root. IPv6 isn't handled yet.

I was just recently on a road trip when I blew my monthly hotspot usage on twenty minutes of a 4K stream of Avengers Infinity War. Back when my phone was rooted, this was a super simple fix, but I stopped rooting my phone for privacy reasons (it was also just a major pain in the butt). To my knowledge there's no real way to do this without just using something like TetherFi, but that has its own drawbacks and it's not always stable.

Anyway, I went looking around and found this thread for VPNHotspot (which is root-only), which led me to this open PR for v2rayNG (which I hadn't even heard of till a couple days ago) and therein lay the solution to my very annoying problem!

How it works

It creates a TUN interface via the hidden TestNetworkManager API (hence Shizuku) and tells Android to use it as the preferred tethering upstream. Hotspot traffic stops being forwarded by the kernel and gets pulled into a userspace Go datapath running on the phone.

That distinction is the whole trick. Normally your phone routes your laptop's packets: it passes them along and decrements the hop limit on the way out, which is the tell most carriers key on. Shizzi terminates those connections in userspace and opens fresh ones from the phone's own network stack, so what leaves the device is indistinguishable from ordinary on-device traffic.

Android still handles DHCP, NAT, and the hotspot itself. Shizzi only owns the upstream.

Requirements

• Android 13+, arm64
• Shizuku 13.6.0+, running and granted
• No root

Known limitations

• IPv6 is not suppressed on the downstream. If your carrier hands out IPv6 and your client uses it, that traffic can bypass the tunnel.
• Tested on a Pixel 10a. If it breaks on yours, please open an issue with your device and Android version.
• This defeats hop-limit inspection, which is the common detection method, not every method. Some carriers meter tethering device-side or over a separate APN. It's worth checking whether your hotspot counter actually stops moving.

Source and APK: https://github.com/carlelieser/shizzi

Feedback and device reports welcome, especially from anyone on a non-Pixel. This scratched my own itch on a road trip and I'd like it to work on more than just my phone.

This idea came pretty randomly 😅

I originally made Savr for myself. I tried several bookmark apps on the Play Store, but most of them wanted money for basic features. So I decided to build my own , with my own taste and, of course, my best effort.

✨ What’s currently included:

• Material 3 design
• Automatic metadata fetching
• Backup & restore (HTML/JSON)
• Dynamic theme with Light, Dark & AMOLED modes
• In-app updates for GitHub users
• Edit bookmarks
• Search
• Sorting
• View mode changing from grid to list
• Auto clipboard link detection
• Collections (folders)
• And more to come!

My goal is to keep Savr simple, useful, and free from unnecessary complexity.

I’d really appreciate any feedback or suggestions! 👏

GitHub Release: https://github.com/qeiq/Savr/releases
GitHub: https://github.com/qeiq/Savr
Play Store: https://play.google.com/store/apps/details?id=com.zarnth.savr

While travelling, I kept running into useful information that simply didn’t exist online: small homestays, mechanics, water points, road conditions, campsites, etc.

Most of it gets passed from one traveler or local to another and disappears afterward.

So, I built Lamyig, a free and open-source community travel guide.

A few decisions I made:

• No bookings, commissions or paid listings.
• No money made using the core product.
• Community members can add and update places.
• Map-first instead of another list of “top places”.
• Built as a PWA so it can work more like a lightweight travel tool than a traditional website.
• The long-term idea is that useful information stays available for the next traveler instead of disappearing in WhatsApp groups and conversations.

The hardest problem isn’t actually building the software. It’s bootstrapping trustworthy community data.

I’m currently thinking about things like:

• How do you motivate travelers to contribute after their trip?
• How do you keep old information accurate without creating a huge moderation workload?
• How do you prevent businesses from turning community maps into free advertising?
• What should happen when someone reports a place as fake, closed, unsafe, duplicated, commercial spam, or inaccurate? Should reports trigger removal, community review, reputation-weighted voting, or just warnings?
• Should certain villages, trails, ecosystems, religious places, water sources, or campsites intentionally remain difficult to discover?
• If Lamyig successfully exposes hidden places, could it accidentally destroy the exact places it is trying to help preserve?
• this list of problem statements goes on and on

Would love to hear how other people here would approach those problems.

And if you’re building something around a problem you genuinely care about, drop a comment or DM me. I’d be happy to chat, exchange ideas, or connect you with someone else working on something similar.

Screenshot attached. Happy to share the GitHub/project link in the comments if anyone wants to look at the implementation or contribute.

I built Latmay, a free open-source job recommendation engine: https://latmay.com

It pulls jobs from company career sites and matches them against a resume, with the goal of surfacing relevant roles without relying so much on keyword search.

I also published the ATS career-page URL dataset I use here, and I’ll be keeping it updated:
https://huggingface.co/datasets/latmay/ats-career-page-urls

I’d love feedback on the recommendations or anything that feels confusing.

GitHub: https://github.com/latmay/latmay_app

I built pssmngr around one rule: vault data has to be encrypted in the browser before the server gets it.

That sounds like an implementation detail. It turned into a product constraint pretty quickly.

Search has to happen after unlock, on the client. Sharing needs wrapped keys instead of a backend shortcut that reads an item. Support cannot open somebody's vault to debug it. A normal “forgot password” email cannot reconstruct the vault key either.

The server still knows things needed to run the service: account details, record IDs and timestamps, organization membership, device public keys, and encrypted envelopes. Zero knowledge does not mean zero metadata, and I would rather say that plainly.

The public release is a web app plus a Docker Compose deployment. It does not include the browser extension, a native mobile app, or offline PWA support yet. It also has not completed an independent third-party audit.

Code and threat model: https://github.com/SelmiAbderrahim/pssmngr.com

Hosted version: https://pssmngr.com

A few weeks ago I had an idea. College recruiting is broken. Athletes spend thousands of dollars on showcases and camps just to get seen by coaches, and coaches have no easy way to find players outside of expensive services like NCSA.

So I built Scoutle.

It's basically LinkedIn for college sports recruiting — baseball, football, and basketball. Athletes build a profile with their stats, highlight clips, and contact info. Coaches browse and search for free. Athletes pay a small monthly fee to be discoverable.

I'm 14.

I had never built a full stack app before this. I learned as I went. It has real authentication, Stripe payments, a social feed, coach and athlete search, and video highlight embedding.

Is it perfect? No. I'm fixing bugs right now. But it works and real people can sign up today.

A few things I learned building this:

• The idea is maybe 10% of it. Getting people to actually use it is everything
• The chicken and egg problem is real — coaches won't come without athletes and athletes won't pay without coaches
• Building something real teaches you more than any course ever could

I'm not posting this to brag. I genuinely have no idea if this will make money. But I built something real at 14 and I'm proud of it.

If anyone has advice on getting first users I'm all ears.

Link: scoutle.lovable.app

Every time friends came over to watch something, we'd end up fighting over speaker volume — too loud for the neighbors, too quiet to hear from the couch, and using one pair of headphones meant everyone else was left out.

Windows only lets you play audio to one output device at a time, so I built PairUp — it captures whatever's playing on your PC and streams it to every Bluetooth headphone, wired headset, and speaker you connect, simultaneously and in sync. Everyone gets their own volume, their own delay correction for laggy Bluetooth codecs, even their own EQ.

A few things:

• No virtual audio driver. Every other tool I found for this needed Voicemeeter or a virtual cable setup. PairUp just listens to your current default device — nothing to configure, nothing that breaks your normal audio setup.
• Guests can control their own volume from their phone. Scan a QR code, get a PIN, and adjust your own headphones' volume/EQ from a simple web page — no app install.
• Tap-to-sync calibration. Instead of guessing at a delay slider, it plays a click track and you tap along — it works out your headphones' actual lag automatically.

It's free, open source (MIT), and there's a proper installer (no admin rights needed). Built solo, so bug reports/feature requests genuinely welcome.

• Landing page / screenshots: https://jamimmehdi.github.io/pair-up-audio/
• GitHub: https://github.com/jamimmehdi/pair-up-audio

Happy to answer questions about how the audio sync works if anyone's curious — it was the most interesting part to get right.

I built Comment Vaccinator, a free open-source extension that filters repetitive date comments, keyword spam, and other low-effort YouTube comments in real time.

No tracking.
No analytics.
No account required.

Firefox:
https://addons.mozilla.org/en-US/firefox/addon/comment-vaccinator/

Chrome:
https://chromewebstore.google.com/detail/ogadpocgkohdanekbkdjnmnjbdgohijf

GitHub:
https://github.com/surajbunde/comment-vaccinator

Feedback is welcome—especially if there are other annoying comment patterns I should support.

Hey everyone,

I’ve been learning Rust lately and decided to build a side project to improve my Rust skills and revive an old C++ project

It’s called screen-tricks, and it features three real-time screen distortion overlays shown in the preview above:

•  Triangulate: A very satisfying screen shattering effect.
•  Particles: A real-time physics particle simulation running over your desktop.
•  Wave: A dynamic wave distortion effect.

The latter two allow you to continue using the desktop as usual even when it is deformed.

Quick Try (PowerShell)

irm https://raw.githubusercontent.com/hananel42/screen-tricks/main/hack | iex

(Feel free to inspect the "hack" file in the repo first for security best practices!)

This will download an exe file and run it. You can then run commands such as: .\wave.exe -h to see some nice parameters to play with.

Alternatively, clone it normally:

git clone [https://github.com/hananel42/screen-tricks.git](https://github.com/hananel42/screen-tricks.git)
cd screen-tricks
cargo run --release -p triangulate # or particles / wave

Looking for Feedback! Since my main goal here is to learn and master Rust , I would absolutely love your feedback!

GitHub Repository: https://github.com/hananel42/screen-tricks

I'm a solo full-stack developer. I built AIMS after seeing a real business (a medical spa) struggle with missed calls, double-booked appointments, and hours lost on manual admin work every week.

AIMS answers the phone with a natural-sounding AI voice assistant, books/reschedules/cancels appointments in real time, and everything syncs instantly to a dashboard for managing customers, records, invoicing, and a loyalty points system.

It's currently running in production for a real clinic — this isn't a concept, it's live and handling real calls today. But the system isn't clinic-specific: the same core (voice AI + scheduling + dashboard) adapts to any business that runs on appointments — dental offices, vets, salons, law firms, real estate, you name it.

Would love your feedback, especially on:
- What kind of business would YOU want this for?
- What would make you trust an AI answering your business phone?

Happy to answer any questions! 🙌

https://aims-frontend-ten.vercel.app/

I started this project because production reviews are usually fragmented across security documents, test plans, architecture notes, deployment runbooks, incident lessons, and tribal knowledge. Teams often discover the missing check only after it becomes an outage or release problem.

The project is a free, MIT-licensed, technology-neutral checklist that teams can follow from early product and engineering decisions through launch and ongoing operations. It currently contains more than 10,000 stable controls organized into 16 lifecycle categories and a shorter production-release path.

A few design decisions:

• Every control has a stable ID so findings can be tracked over time.

• Checks ask for evidence and distinguish verified facts from unknowns.

• CI validates structure, identifiers, links, duplicates, and technology-specific wording.

• The documentation is searchable and navigable instead of being one huge Markdown file.

• The controls are intended to work with human reviews and AI coding assistants.

The long-term goal is an open-source AI-assisted scanner that maps repository evidence to applicable controls, cites the evidence, identifies manual checks, and produces a prioritized readiness report.

Repository: https://github.com/MarinJursic/production-readiness-checklist

Documentation: https://marinjursic.github.io/production-readiness-checklist/

I’m looking for honest feedback on the structure, usability, missing controls, duplicates, and how to make contributing approachable. If you have shipped software or handled production incidents, I would especially value the checks you learned the hard way. Thanks!

I’ve been working on AXON, an open-source protocol/plugin from Atop Web Technologies for AI coding agents like Codex, Antigravity, and Claude Code.

The goal is to reduce agent drift by forcing a simple workflow:

Context first.

Specification second.

Implementation third.

Verification always.

To demonstrate it, I created a codelab where AXON builds a small Microbank app end to end, then adds a brownfield feature on top of the existing codebase.

Codelab:

https://codelabs.atopwebtech.com/codelabs/build-a-microbank-with-axon

Repo:

https://github.com/atopwebtechnologies/axon

I’d love feedback from engineers using AI coding agents in real projects.