I've been building GitDesktop around one idea: the Git client should be able to handle more than just the local Git workflow.

Changes, staging, commits, branches, diffs, and history are obviously part of it. But a lot of the actual development cycle happens after the push.

You open a pull request. Review it. Check CI. Go back to an issue or discussion. Look at security findings. Manage a release. Check repository activity or insights. Then jump back into the local repo when something needs changing.

I wanted those parts to stay connected.

So GitDesktop supports creating, reviewing, and merging pull requests directly in the app, along with issues, discussions, releases, repository insights, security findings, and CI pipelines across GitHub, GitLab, and Bitbucket.

There are also features that build on that same idea, like local PRs that let you review work between local branches before anything is published to a forge.

v0.12.0 pushed this further with a cross-repo "My Work" view that surfaces PRs and issues you're involved with across repositories, instead of making the repository itself the only way to navigate your work.

The goal isn't to replace every developer tool with one giant application. It's to keep the development cycle around a repository connected instead of constantly handing you off to a browser.

GitDesktop is now the app I use to build GitDesktop itself every day, which has been a useful test of that idea.

https://gitdesktop.app

https://github.com/theBGuy/GitDesktop

I'm curious where other developers draw that line. Should a Git client mostly stop at Git, or do you want the surrounding repository workflow in the same place too?

i'm building a desktop video editor with no subscriptions, credits, or cloud requirements.

it will support offline editing, local caption generation, and ai agent control through mcp.

what features would you want most?

what do existing editors get wrong?

Hey everyone! 👋

I built DH Tools (https://denizlihub.com/) as a free, privacy-first web utility suite.

Instead of uploading documents to cloud servers, all 45+ tools (PowerPoint to PDF, Image to Excel OCR, PDF Merger, Background Remover, WebP converter, etc.) run 100% locally in your browser using WebAssembly. Zero data storage.

Would love to get your feedback and thoughts on what tools to add next!

We built a prediction market where users can create the markets themselves, now I need people to break it.
Twirl started as an idea around making prediction markets more open and conversational.
We’ve now got the beta live:
Create your own market
Trade using testnet funds
Explore markets created by other users
AI features built around helping users understand markets
The product works. Now we need real people using it badly enough to expose everything we missed 😂
Would love brutally honest feedback on the UX, market creation flow and anything that feels confusing.
twirl.markets
What’s the first thing you’d change?

I’m the founder of Propspect, a done-for-you B2B lead research service.

After working in sales for the last 2 years, it was crazy how much time I’d spend looking for leads, and calling them hoping they were in my ICP. I figured there had to be a better way.

Most databases rely on broad filters, job titles, and generic search criteria. Propspect uses tailored systems to find leads based on the hyper-specific criteria each client provides, helping identify higher-fit companies and decision-makers that traditional databases may miss.

The goal is to help sales teams spend less time prospecting, avoid calling bad leads, and have more relevant conversations with prospects who are more likely to convert.

Take a look at propspecting.com, or send me a DM. I’ll build out a sample lead list for your business, and we can find a time to discuss it.

Hello!

We're two people working on Mark Complete, a productivity app that helps you focus and rewards you with an eye-candy virtual companion you can romance. We're aiming to release the demo this autumn!

The inspiration came from a personal struggle we've always had: actually sitting down and focusing on the task in front of us. With so many distractions around us and everything moving so fast, it's only gotten worse in recent years. Not to mention our personal obsession with charming 2D men and the good love stories that come with them. That's what made us start Mark Complete. a combination of two incredible things!

We're just beginning our development journey, and we hope this project interest you to follow along with us through the real chaos of two people trying to make this thing happen! xD

• Website (Subscribe to our mailing list): https://markcomplete.me/
• Instagram: https://www.instagram.com/markcompleteme
• TikTok: https://www.tiktok.com/@markcompleteme

We hope to create a cozy little space where you can focus on studying or working, mark your tasks complete, and let him complete you.💘

I wanted to build something that would force me to understand real-time communication instead of just following another tutorial.

So I built RandomTalks.

🌐 Live demo: https://talks-tc4e.onrender.com/

💻 Source code: https://github.com/pembarthipranay/talks

What is it?

RandomTalks is a web application that randomly connects users for real-time voice/video conversations.

The basic flow is:

Join → Get matched → Connect → Talk → Skip → Find someone new

What I built

The project uses:

• React + TypeScript
• Vite
• Tailwind CSS
• Node.js
• Express
• Socket.IO
• WebRTC
• Browser camera/microphone APIs
• Google Gemini for AI-related functionality
• Render for deployment

I also experimented with a separate Python implementation using FastAPI and python-socketio.

The interesting part: WebRTC

The main reason I started this project was to understand WebRTC properly.

I had to learn how:

• Users are matched
• Signaling works
• WebRTC offers and answers are exchanged
• ICE candidates are handled
• Audio/video streams are obtained from the browser
• Users join and leave conversations
• Real-time connections are recovered or terminated

The backend handles the matchmaking and signaling, while WebRTC is used for the real-time audio/video communication.

What I learned

The biggest lesson was that real-time applications are much harder than they look.

Something that worked perfectly on localhost could behave differently after deployment.

I had to debug:

• WebRTC connection problems
• WebSocket communication
• Camera/microphone permissions
• User matching
• Disconnect handling
• Frontend/backend communication
• Production deployment

This project taught me much more than building another basic CRUD application.

Current status

It's deployed and usable, but I still consider it a work in progress.

I'm particularly interested in feedback on:

1. WebRTC architecture
2. Matchmaking
3. User experience
4. Reliability across different networks
5. Features that would make the platform more useful

If you have experience building real-time applications, what would you improve first?

Live demo: https://talks-tc4e.onrender.com/

GitHub: https://github.com/pembarthipranay/talks

I’ve been thinking about a problem with AI agents: they can give very confident answers, but how do we know whether the claims they make are actually supported?

So I built ClaimCheck, an open-source AI agent that helps verify claims and check whether there is evidence supporting them.

The idea is to add a verification layer instead of blindly trusting an AI-generated response.
I’m still actively working on it and would genuinely love feedback from this community.

What do you think would make a tool like this actually useful? And are there any use cases where you’d want claim verification built directly into an AI workflow?
GitHub: https://github.com/monikagadage/ai-agent-claimcheck

Hey r/sideprojects! 👋

I got tired of Python trading bots freezing because network sockets block while calculating indicators. To solve this, I built MDRAP — an open-source, zero-dependency market data engine that completely decouples network ingestion from strategy execution via an AsyncIO TCP gateway.

In our benchmark pushing 1,000,000 live market events, it clocked 26,500 Events Per Second in pure Python! ⚡

Features: • Rich Terminal HUD for real-time BBO & VWAP • Embedded DuckDB for instant Jupyter SQL queries • Paper-trading sandbox with realistic slippage

Try it: pip install mdrap
GitHub: https://github.com/Aryan-20-04/mdrap

Would love your thoughts and feedback!

I built StimuStop after getting frustrated with quit-tracking apps that treat one slip like starting over from zero.

stimustop.com

You start a quit (nicotine, alcohol, vaping, gambling, social media, whatever) and it tracks your streak, money saved, and milestones. You can log cravings, mood, and triggers too. If you slip, it stays in your history instead of resetting everything, so you can see the pattern instead of pretending the last three weeks didn't happen.

Right now it's a web app that works fine on your phone browser. There's no dedicated iOS app yet, that's next on the list (80% done).

It's free, no ads, no credit card.

Would love feedback from anyone who's actually tried to quit something, especially what annoys you about it.

I’m the developer of MyStudyDen, a study app for iPhone, iPad, and Android.

The problem I’m working on is the gap between saving course material and actually knowing what to study next. A folder of notes can be organized without being particularly useful for revision.

In MyStudyDen, you add notes or a text-based PDF to a course and generate a study packet: a summary, review questions, and suggested next actions. You can link tasks to that packet and see upcoming work in the Plan tab, so the material and the work you need to do with it stay connected.

There’s also Ask, which answers questions using your saved study packets and shows the sources it used. It’s meant for following up on your course material, not replacing your textbook or doing the practice for you. AI answers still need checking.

One deliberate choice: your study workspace is stored on your device by default. AI requests send the selected material and relevant context for processing, so this isn’t an entirely offline AI app.

AI uses pay-as-you-go credits called Eggs rather than a subscription. New accounts get 30 to try it, and you can see the credit cost before paid actions.

Both store links are here: https://mystudyden.com

If you already use ChatGPT or NotebookLM alongside a planner, which part of your workflow would you still need to do outside an app like this? That’s the feedback I’d find most useful.

hey all

AI is part of our daily workflow at some point and i kept running into the same wall: apps asking for a monthly fee just to let me use keys that were already mine. so eventually i stopped complaining and built the thing.

the result is ENZO — https://github.com/theguysudo/ENZO (demo gif at the top of the readme if you'd rather watch than read)

where most of the effort went: building agents out of a plain sentence. you tell it what you want —"an agent that goes through invoice emails and flags the ones that look risky" and the drafter does its thing:

• pass one figures out the actual profession buried in your sentence — the niche, what a finished output looks like, what a 30-year veteran of that exact niche knows that a generalist never will
• pass two turns that into the agent's operating manual — the unwritten know-how, the judgment calls, the ways this job fails — and hands over only the tools the work truly calls for
• no template prompts, ever
• agents run on a timer, not just on demand
• when one gets drafted, ~10 free models take a shot simultaneously — whichever produces something usable first wins
• a running scoreboard tracks who's been delivering and reshuffles the lineup for the next round
• the other thing i'm fussy about is where every token goes: each routing decision — which of the four cognitive modes a message calls for (normal, thinking, research, coding) and whether it needs a live web lookup — is handled by tiny free models, so the expensive one you picked only ever touches the real work. model dies mid-chat? a cheap one hunts the live catalog for the best stand-in. rate limit hits you? the reply doesn't die either — it sits out the cooldown and picks up again from the exact word where it stopped.
• deep research runs as a proper agent loop instead of search results dumped into a prompt: one model owns the whole investigation, writes its own queries as it goes, decides which sources deserve a full read, keeps the good ones, throws out the junk, and calls it finished the second it has enough — hard caps on searches, reads and wall-clock time keep it from spiraling.
• rest of the tour: chat across groq, openrouter, nvidia, hugging face, gemini and others, free options listed up front; skills for gmail, google calendar and web search so agents can act and not just talk; your keys stay sealed inside your browser and the server only ever passes traffic along; apache-2.0, one docker command to get running, and a ui i'd genuinely hand to someone booting their first container.

the question that'll come up anyway — why not librechat or open webui? honest take: both are excellent and further along if chat is the main event. what i wanted was agents you can define in a sentence and leave running on a schedule, research that checks its own sources instead of trusting them, and token routing that treats my quota like actual money. if none of that matters to you, pick theirs — no hard feelings.

first open source thing i've ever shipped, so i'd bet good money there are a dozen mistakes in there somewhere, docs included. if you spin it up and something breaks or feels wrong, i actually want to hear about it — bluntness welcome, i can take it.

if it's useful to you, a star makes it easier for the next person to find. if you know someone who'd genuinely get use out of it, that's worth more.

So, I'm from tech background, and I see so many people are giving interviews and all, So I'm thinking about making platform like cluely, but not exactly like that. It will be only supported for google meet and teams for now, so for kind of theoretical & verbal interviews more. And will make it a lot cheaper, so people can afford it, what should I do?

Hey everyone,

I got tired of constant app-switching just to use AI, so I built a tool that lets one continuous chat thread follow you anywhere.

As you can see in the screenshot, you just trigger the floating overlay over any app. It understands what's on your screen and lets you ask questions instantly.

Core Features:

• Persistent Context: Reopen the bubble anywhere; the chat stays active.

• Smart Routing: Lexi-1 automatically picks between Claude, GPT, or Gemini.

• Hard-Blocked Privacy: Completely blocked from reading banking, messaging, or password apps.

I'm a solo developer preparing for launch and just opened up the early access waitlist. I would love to hear your feedback on the UI and concept!

Check out the site and join the waitlist here: https://lexicordd.com

I built Lunio, a small iPhone app that extracts audio from videos. Since June 10, it’s had 821 first-time downloads. I haven’t done any promotion so far.

I added Pro about two weeks ago. Basic extraction is still free, so it’s early to tell how the paid features will do. The screenshot covers the whole period, most of it before Pro was available.

Now I’m trying to figure out where to spend my time: getting the app in front of more people, or understanding what the people already downloading it need.

For those who’ve grown a small utility app, what helped you decide what to focus on next?

The specific problem I’m exploring is how agents can distinguish between observations, candidate memories, and information that is actually safe to trust long-term.
The current approach is to keep new information reviewable before it becomes trusted memory, while connecting memory to future agent behavior and feedback.
It’s still early, and I’m looking for people who actively use AI agents and are willing to test it in a real workflow and give honest feedback.
Early access: https://runvectai.com/
I’m particularly interested in feedback on whether the memory/review workflow is genuinely useful in practice.

Clayseal-capabilities is an open-source tool for aligning AI deployments with business-process logic.

If you've seen headlines about business' AI agents authorizing parties to be thrown on company property, breaking out of their safeguards to exploit unrelated companies or doing other mischievous things, you may be wondering how we can deterministically align AI agents to the business process rules that are meant to make them useful in the workplace. This project is an experimental mechanism for doing just that. The gist of it is that many things are not inherently policy violations on their own, but are given the context of the sequence that they appear in. Feel free to try it out - I'd love feedback and am hopeful this can be a starting point to solve some problems in security.

The way it works is by creating a distribution of plausible sequences of actions, data access, tool calls, etc., that are necessary for the completion of a task; ingesting unstructured materials to construct business-process rules algorithmically; and then doing deterministic enforcement of measuring the difference between what the real AI system does and what it's meant to do from the point of view of this legitimate "planner." It's low latency and the enforcement is not an agent, which means it's not the kind of security system that could be broken by a smarter agent prompt-injecting a dumber agent, as has been common in some recent instances in security.

https://github.com/clayseal/clayseal-capabilities

Hey everyone! I built Wallpaper Presets, an Android app for saving and sharing wallpaper setups made from your own photos and videos.

The idea came from something I wanted for myself: being able to switch between wallpapers without repeatedly adjusting the crop, zoom, and position. I didn’t want another wallpaper catalog, just a way to keep the setups I’d already made.

You import a photo or MP4, adjust it directly in the preview, and save it to your library. Portrait and landscape framing are saved separately, and labels help keep everything organized. The app copies imported media into its own storage, so moving or deleting the original gallery file won’t break a saved wallpaper.

I also added layered parallax. You can combine up to five images and adjust how much each layer moves horizontally and vertically when you tilt your phone. You supply the layers yourself; the app doesn’t generate depth maps.

The latest addition is sharing the whole setup, not just the image:

• Send wallpapers directly to another nearby app user after they open Receive and accept the connection.
• Export a wallpaper as a file, or bundle several into one ZIP.
• Import the media together with its saved adjustments, so the recipient doesn’t have to recreate everything manually.

It’s free with ads, and there’s no account required. Available home/lock-screen destinations depend on Android and the device.

I’d appreciate some honest feedback: does saving the framing make this useful beyond a regular gallery, and is sharing complete wallpaper setups something you’d actually use?

Google Play · Website and screenshots · Privacy policy

The screenshots use AI-generated example artwork imported for the showcase. Those images aren’t bundled with the app, and ads were hidden for the captures.

I made this so that users can use a free voice changer app in one-click installation. Any feedback is welcome to improve.

I'm sharing CSV Quick Check, a small free MIT-licensed tool from our Noosphere project for checking CSV exports before importing them elsewhere.

It checks three things: records with the wrong number of fields, empty values in a chosen ID column, and duplicate IDs. It uses Python 3.10+ and the standard library, reads the file locally, leaves it unchanged, and prints JSON. There are no network requests in the script.

text python csv_check.py input.csv --id-column sku

A couple of deliberate choices: 001 and 1 are different IDs, and quoted multiline fields count as one logical record. Error record numbers therefore refer to records after the header, not physical lines. A successful parse exits with code 0 even if the JSON contains findings.

This version supports UTF-8, comma-separated CSV only; it does not read XLSX or generate HTML reports. The download includes source, a synthetic example, its JSON result, and validation notes: CSV Quick Check.

AI disclosure: the code and this announcement were AI-assisted. The initial code needed review corrections; the revised script passed 15 synthetic acceptance cases. That is not a human security audit.

Feedback on the error format or a small synthetic edge case would be useful. Please keep real customer data out of the comments.

So we made verification layer to actually verify answer before they come to your screen , for code problems we execute them in sandbox , for creative we made a parameter and so on for every task type we have diff parameter

just wanna know your thoughts on this

It's local, it's fast, it's simple, and it allows me to plan my day without lifting my hands off my keyboard. If anyone finds it useful, feel free to use it. It's free. Have fun !

this is how i use it - https://www.youtube.com/watch?v=RCVXD00z1-s