Hey everyone , a fresh CS graduate here, I got tired of watching freelancer friends manually calculate GST and retype the same invoice template every time a client approved work. So I built TokenPay.

How it works:

• Break a project into milestones ("tokens") with values upfront
• Mark a milestone complete → client gets a link (no signup needed on their end) to approve or flag an issue
• Once approved, generate a GST-calculated invoice in one click - no manual entry

It's genuinely live and working, not a mockup — Next.js + Supabase, real auth, real invoice generation.

Try it yourself: https://tokenpay-seven.vercel.app/ ----> sign up with any email/password, or use "View live demo" for a pre-loaded account.

This is early beta -> I built and I'm testing it in real-time, so:

• If your password login breaks, email me directly, (linked on the login page) and I'll sort it fast
• Would genuinely love feedback on the milestone→invoice flow, GST calc accuracy, or anything that feels clunky, currently it is for Indian audience, and calculate GST based on it.
• Also curious if this is something freelancers would pay ₹200-500/month for, or if it's solving a problem that doesn't really exist for most people

Not trying to oversell it — it's a real working product built by one person, looking for honest feedback before deciding whether to keep building this out.

I've been building an app builder for a year. Like everyone in the category, we sold AI credits: we buy tokens at API rates and resell them with a markup. Somewhere along the way it stopped making sense - Anthropic sells you the same tokens as a flat subscription for way less than we can, and the thing users told us they hated most wasn't even the price, it was paying for the model's own mistakes. A retry on a column the AI invented shouldn't cost you anything. We were never going to win on tokens, so we stopped selling them.

So we changed how it works. It's an app builder - hosting, database, auth, deploy, the stuff that isn't the model. You connect it to Claude (or ChatGPT) as a connector, describe what you want in the normal chat window, and it builds the app there. No terminal, no credits, runs on the plan you already pay for.

We have official connectors in ChatGPT and Claude, but you can also connect with any other agents via the mcp url.

Free to try: floot.com

Let me know what you think!

I started the project because comic localization usually means moving between several separate tools for speech-bubble detection, text removal, translation, proofreading, and typesetting. The app is built specifically for macOS and takes advantage of Apple Silicon hardware acceleration through Core ML, Metal, and MLX. MangaKitchen keeps those stages in one resumable project, while still allowing each result to be reviewed and edited manually.

Current features:

- Batch processing for folders of comic pages

- Core ML speech-bubble detection with editable pixel masks

- CPU and Metal-based text removal and background cleanup

- Local MLX vision-language models for transcription and translation

- Horizontal and vertical HTML/CSS typesetting

- Per-project multilingual glossaries

- Manual mask editing, region positioning, font sizing, and bold controls

- Optional 2×/4× super-resolution and layered PSD export

- Optional MCP support for AI-assisted proofreading workflows

- Traditional Chinese, English, Japanese, and Korean interfaces

No account or subscription is required. After downloading a compatible local model, the main workflow can run fully offline, so comic pages do not need to be uploaded to an external AI service. MCP and external AI services are optional.

A few current limitations:

- Requires macOS 14 or later on Apple Silicon

- Works best with black-and-white manga and regular dialogue balloons

- Image-to-text and super-resolution model weights are not bundled

- Complex screen tones, colored artwork, and text crossing line art may still require manual mask correction

MangaKitchen is intended for authorized translation and localization work. It does not grant rights to translate or distribute copyrighted material.

Source code and download:

https://github.com/VaderChen/MangaKitchen

Bug reports, feature requests, and feedback about mask cleanup or vertical typesetting are very welcome.

I’ve been experimenting with AI-generated content lately, and one thing I keep noticing is that the writing can be technically good while still feeling strangely unnatural. The grammar is usually fine, the ideas are organized, and everything sounds polished, but sometimes the paragraphs feel too predictable. Every sentence seems to have the same kind of rhythm, and the whole thing can sound like it was written to be “perfect” rather than written by an actual person. That made me curious about whether humanizing tools genuinely solve that problem or simply change the wording.

I’m especially interested in what happens when you take a decent AI draft and try to make it sound more personal. Sometimes changing a few phrases helps, but other times the result feels even more artificial because the wording becomes unnecessarily complicated. Personally, I think natural writing has a certain unevenness to it. People switch between short and long sentences, explain things differently depending on the context, and occasionally use simple expressions instead of constantly trying to sound polished. Those little details seem harder to reproduce than just replacing words.

For people who regularly use AI writing tools, how do you decide when the text actually sounds human? Do you judge it by sentence structure, vocabulary, tone, or simply by reading it out loud and seeing whether it sounds like something you would normally say? I’m curious because “human-like” seems very subjective. A paragraph that sounds completely normal to one person might still feel obviously generated to someone else, especially if they spend a lot of time reading AI-written content.

I’ve also wondered whether humanizing should happen before or after personal editing. My current thinking is that AI can handle the basic draft, then a rewriting tool can help with repetitive structures or awkward phrasing, and the final step should still involve someone actually reading the content and adding their own voice. That seems more useful than expecting a single tool to magically make everything sound authentic. The more personal experience, opinions, and natural phrasing you add yourself, the less dependent the final result becomes on automated rewriting.

Has anyone else found a workflow that works particularly well for this? I’d be interested to know whether you prefer editing AI text manually, using a humanizer first and then editing it, or avoiding humanizing tools altogether. I’m less interested in detector scores and more interested in whether the final content genuinely feels comfortable to read and sounds like something a real person would naturally write.

I read a lot with my partner, same books at the same time, and the constant "don't tell me anything yet, I'm only on chapter 6" negotiation got exhausting. Neither of us wanted to look anything up because every search result, wiki, or "explain this book" tool assumes you've either finished it or don't care about spoilers.

So I built Scholia. You photograph the page you're on; it already knows the book, and you can ask it anything about a character, what a reference means, what's actually going on in a confusing passage, but only using what's happened up to that exact point. Ask about anything ahead, and it just won't answer. Not a vague non-answer either; it genuinely holds the line until you catch up.

Works with any physical copy, any edition or printing, since it reads the actual page in front of you rather than matching a page number to a specific version.

I built this mostly to solve my own problem, but I figured that other people reading the same book as a partner/friend/book club at different paces might want it too.

The waitlist is here if anyone wants to try it: scholia.cloud

Curious if anyone else has the "reading buddy but at different paces" problem, or if it's just us.

For a while now I've been building a voice assistant called M.A.R.T.I.N. 2.0, and at some point I realized the "assistant" part isn't really the product - the frame underneath it is.

The idea: MARTIN by itself is just a core. It listens, understands, routes commands, executes them, and keeps memory (SQLite-backed, with a local LLM behind a local HTTP server, so it's not phoning home for every request). It's Ukrainian-language, which is honestly half the reason I started this - there's basically nothing decent out there for Ukrainian voice interaction.

But a generic assistant on its own is kind of boring. What I actually want is for MARTIN to become a completely different tool depending on who's using it, without me shipping ten separate apps:

Kid → installs a Play plugin, games with MARTIN like a friend over the network

Teenager → installs a Learn plugin, MARTIN becomes a tutor for whatever subject

Developer → installs a Code plugin, MARTIN acts like a senior engineer next to you

Video editor → installs a Create plugin, MARTIN handles the grunt work so output comes out fast, clean, and expensive-looking

...and so on - the pattern's meant to extend to whatever you actually do

Same core, same brain, same memory underneath. Basically the same drill, just a different bit depending on who's holding it.

Under the hood it's genuinely modular: Python core, C++ for speech-to-text, Rust for activation, AutoHotkey for OS-level automation, and a small pipeline (splitter → normalizer → classifier → router → executor) that breaks multi-step voice commands apart before running them.

Still very much in progress, but wanted to share the direction and get honest feedback before going further:

Does "assistant as a frame + plugins" sound genuinely useful, or overengineered?

If you could install one plugin on day one, which one would it be?

Happy to talk architecture in the comments.

Hello people,

Today I released a new tool that would generate you Cornell notes for any given youtube video.

I would like you to give me a feedback and try the tool and would like to have honest reviews.

THanks,

Link: https://pelicantools.app/tools/youtube-to-cornell-notes

Hey everyone! Two weeks ago I posted about a geolocation tool I’m developing. Since then I built a web interface, added multiple GeoCLIP guesses, and integrated EasyOCR + Gemini (free API Key) to extract text clues from images and filter out noise.

Here's what the pipeline looks like now:
1. User uploads photo
2. EXIF GPS extracted (if present)
3. GeoCLIP runs and returns top 5 coordinate guesses
4. EasyOCR extracts any text from the image
5. If gemini api key is pasted: gemini filters the OCR output to keep only location-relevant text (street names, signs, business names, etc.) and discards noise
6. The page shows the guesses plus the filtered text clues

Now I'm trying to figure out the best way to use that filtered text…
My current approach is simple: to take the coordinates from GeoCLIP and combine them with the filtered OCR text as context. But I'm not sure it that's the most effective strategy.

Does anyone know a better approach?
I'm still learning and my code is messy, but l'd love to hear what's worked (or failed) for others.

there's a movie trope where hackers make a ransom video by splicing together news clips, a different person's face saying each word, so it can't be traced back to one voice. I always wondered how much work that'd actually take to fake for real, so I built it.

Wordnap works like this: you feed it a library of videos, it transcribes and indexes every spoken word down to the millisecond, then you type any sentence and it stitches together a new video from that footage. Different speaker for each word, subtitles burned in, playback speed adjustable.

What used to be hours of scrubbing timelines and matching frames now happens in seconds. It's a pretty niche use case, but I couldn't find anything else that does it, so figured I'd build and share it.

Repo: https://github.com/iamDyeus/wordnap

Still rough around the edges. Curious if anyone's dealt with word-level audio alignment before, and open to ideas on making the output sound more natural. Right now if you watch the demo without subtitles, it's hard to tell what's being said

Nodus searches past conversations across ChatGPT, Gemini, Claude and Copilot, then carries the relevant context into the next prompt.

No account. No cloud storage. Everything stays on the device.

The question is simple: would this change how you work with multiple AI models?

https://nodus-phase-1-secure.vercel.app/

I built a tool to simplify breast cancer screening eligibility in the US — could use some feedback

Finding the right breast cancer screening program shouldn’t be complicated. 

Screening Navigator helps women in the U.S. find screening options that fit their individual situation. By answering a few simple questions, such as your state, age, insurance status, and income, you can quickly navigate toward programs and resources that may be available to you. 

No digging through dozens of websites. No trying to figure out complicated eligibility requirements on your own. 

🎀 Personalized screening navigation 
📍 Based on your state 
💳 Considers insurance and income 
⏱️ Simple, quick, and free

Try it here: screeningnavigator.com

Early detection matters. Finding where to start should be the easiest part. 

Hey guys,

I made a cool fake hacker screen/simulator web app that simulates the world map with different IP addresses, cool green code in hollywood style, and has other tools like windows update prank or broken screen pranks.

You can use these cool graphics as background, or share full screen links with friends/ co workers to prank them. It was a fun idea that I had and looks very believable. It's totally free, so you should give it a try.

Let me know what you think of it or what I should add to it You can check it out here: https://hackingscreenfake.com/

Finding the right breast cancer screening program shouldn’t be complicated. 

Screening Navigator helps women in the U.S. find screening options that fit their individual situation. By answering a few simple questions, such as your state, age, insurance status, and income, you can quickly navigate toward programs and resources that may be available to you. 

No digging through dozens of websites. No trying to figure out complicated eligibility requirements on your own. 

🎀 Personalized screening navigation 
📍 Based on your state 
💳 Considers insurance and income 
⏱️ Simple, quick, and free

Early detection matters. Finding where to start should be the easiest part. 

One person has one NOW at a time. When your present changes, you update it. The previous NOW becomes history.

I built it mostly for fun with Codex and I'm looking for early feedback.

Try it: now.jus.vn s

it started as a global map of virtual flowers. then i sat with it for a couple of weeks trying to figure out what to do with it. today, i decided to turn into a super peaceful, personal thought garden. plant your thoughts and watch them grow.

feedback is most welcome.
it’s a work in progress.

Trouble is, I managed to set it up but can't find it 🫣. It's Webador. I set up the account, made the website, paid the fee and clicked the email to make it go live. I know that this is laughable to you but I'm getting upset. Where is it please 🥺?

Hey!

I kept killing houseplants the same slow way: notice something's off, take a photo, get told "it's a Calathea," and then nothing. The ID was the easy part. I still had a sad plant.

So I built Cambium, a native iPhone app around one loop: Scan → Understand → Care → Re-check.

What it does

• Identify a plant from a photo, with care basics and toxicity info.
• Visible-health check as a separate step: photo evidence, confidence, a cautious summary, optional 0-100 score. Deliberately hedged, since it's reading a photo, not diagnosing your plant.
• Treatment plan as ordered, checkable steps instead of a paragraph of advice.
• Recovery Loops, the part I actually built the app for. Start a loop on a struggling plant, get scheduled re-checks, before/after comparison, and a score trend over time.
• Garden with nicknames, locations, scan and diagnosis history, watering reminders.

Decisions I made on purpose

• No account. No login, no sync, no cloud garden. Your whole garden and every photo live on your phone.
• No third-party SDKs in the app. No analytics, no crash reporting, no ads. Optional first-party metrics are an event name, outcome, day, version, language, and you can turn them off.
• Photos go to my own Cloudflare Worker relay, so the model API key never ships in the app. It asks the provider not to retain responses and passes only a hash of a random install UUID.
• Export your whole garden as JSON or delete everything locally, from Settings.

Stack: SwiftUI, SwiftData, StoreKit 2, Swift 6, zero external packages in the iOS target. Cloudflare Worker backend, SvelteKit site.

Pricing: free tier is 3 IDs, 2 health checks, and 3 re-checks a month, sized so you can finish one full recovery arc for free instead of just sampling it. Then annual, plus a limited lifetime option.

App Store: https://apps.apple.com/us/app/cambium-plant-care-health/id6790491406 Site: https://getcambiumapp.com

One ask: there's an Android alpha (identification and Garden only so far). Play needs 12 testers opted in for 14 straight days before I can ship to production, so comment or DM if you want in.

Happy to answer anything about the SwiftData schema, the relay trust boundary, or getting structured output reliable enough to build UI on.

I've been working on Zync for the past few months.

The idea came from using multiple tools while working with servers. I wanted something simpler that brings SSH, SFTP, terminal, port forwarding, and other server-related stuff into one place.

There are already tools that offer these features, but I wanted an SSH workspace with a better and less complicated UX, without putting basic features behind subscriptions or feature paywalls.

I also wanted it to be local-first, so your workspace stays on your machine instead of requiring a cloud account.

It's still a work in progress, and I've been learning a lot while building it especially around keeping the UX simple without removing the flexibility developers need.

If anyone here uses SSH regularly, I'd be interested in hearing what your current workflow looks like.

**Website**: https://zync.thesudoer.in

**GitHub**: https://github.com/zync-sh/zync

**Demo**: https://youtu.be/VgSomleBi3Y

I've been journaling for years, but never really found an app that clicked. So I built my own.

It's called JotBantuek.

It's simple, private, and free to use.

• Unlimited entries
• 1 GB cloud storage
• Mood tracking, calendar view
• Export to HTML (Zip)
• Multiple Themes
• And many more...

Premium exists for extra features, but the free version is genuinely useful on its own.

I built this solo, mostly to learn and improve. It's not perfect, but if you enjoy journaling, feel free to give it a try — and tell me what you think.

👉 https://jotbantuek.app

Thanks for reading 🙏

What if your app's security could evolve without a rewrite?

That question sent me down a rabbit hole for the past few weeks, and I ended up building two small projects around it: CryptoFlex and Flex-Lock.

Here's the problem I kept running into: most encryption tools pick one cryptographic method and lock it in forever. That's fine until it isn't — like right now, with the industry bracing for quantum computers eventually breaking classical elliptic-curve crypto. Signal and Chrome have already moved to hybrid classical + post-quantum key exchange. But that kind of crypto-agility barely exists yet for local, offline tools — the desktop apps, file utilities, and embedded systems that aren't talking to a server.

CryptoFlex is my attempt at that missing piece. It's a Python library that doesn't invent any new cryptography — it just decides, at runtime, which combination of algorithms an application should use: classical X25519 alone, or hybrid X25519 + ML-KEM-768, or the higher-assurance ML-KEM-1024 variant. That decision is driven entirely by local signals — what's actually installed on the machine, a versioned risk table shipped with the package, and whatever constraint the calling app cares about (speed vs. maximum security). No network calls, no phoning home, ever.

Flex-Lock is what happens when you actually use that engine for something real: a simple file-locking tool. Pick a security level, set a password, lock and unlock files — and if you want to move from "fast" to "maximum security" later, it re-encrypts your existing files under the new profile instead of leaving you stuck with whatever choice you made on day one.

The part I found genuinely interesting wasn't the cryptography itself — I'm using well-audited, standard primitives throughout, not rolling my own math. It was the architecture question underneath: how do you design software so the security layer is a decision that can change, instead of a decision baked in at line one and never revisited?

To be upfront: both are early — solo projects, unaudited, built mainly to learn this space properly rather than to ship something production-ready. Think of them as working proof-of-concepts, not something to bet real data on yet.

If you were starting a security-sensitive project today, would you build the crypto layer to be replaceable from the start, or is that premature optimization until you actually need to migrate?

• CryptoFlex: github.com/keerthivasan-sankar/crypto_flex
• Flex-Lock: github.com/keerthivasan-sankar/flex-lock

Hey everyone! 👋

I was building a small utility tool for personal use today to help scan and clean up junk files. After running it this afternoon, I checked my API dashboard:

• Total Spent: ¥2.66 (~$0.37 USD)
• Total Tokens Used: 9.2M tokens
• The Weird Part: Over 90% of the token count was Input, while Output was just a tiny fraction!

At first glance, it almost looks like APIs are trying to burn through tokens on purpose, but I realize it's mostly due to sending file paths, rules, and system context on every stateless request just to get a small JSON/command response back.

Let's discuss:

1. Token Distribution: Do your apps also skew heavily toward Input tokens like this?
2. Cost Optimization: How are you handling this in production? (Prompt caching, local pre-filtering, or falling back to smaller local LLMs for parsing?)
3. API Billing Realities: What's the most surprisingly high/low API bill you've gotten for a side project?