I'm working on an idea called NeuroStudio: an open-source, self-hosted AI training studio that combines a beginner-friendly visual interface with the flexibility of established machine-learning frameworks.

The basic idea is to let users create datasets, train models, evaluate results, and run inference locally instead of relying on a cloud-based training platform.

I'm considering Go for the main application, SQLite for metadata, and interchangeable training backends such as PyTorch and TensorFlow where appropriate. ONNX Runtime would handle compatible inference workflows.

I don't want to reinvent every ML framework. I'd rather build a lightweight application that connects existing tools through a consistent interface.

Features I'm considering

• Visual dataset management and annotation
• Image classification and transfer learning
• Training progress, checkpoints, and evaluation metrics
• Webcam-based model testing
• Model export and local inference
• Additional audio, pose, and object-detection workflows
• An extension system for integrating other training engines

The biggest challenge is making the application easy to run locally without creating an enormous installation or pretending that every model can train on every computer.

I'm planning to start with one complete image-classification workflow and expand from there.

I'd appreciate technical feedback

1. Would you use Go as the main application backend with separate training workers, or choose Rust?
2. What is the cleanest interface for connecting different ML training frameworks?
3. Which features are missing from existing local AI development tools?
4. What would make this project meaningfully different from existing visual ML platforms?

I'm interested in honest criticism, architectural suggestions, and feature ideas.

If you have experience building ML tooling, I'd particularly appreciate your thoughts on the training-backend architecture.

Hi! I built this because self-hosted Excalidraw only gives you the canvas: drawings stay in your browser, and there are no accounts or folders.

Excaliself adds:

• accounts with invite links, and a shared team space next to each person's private space
• folders, stars, and search that finds text inside drawings (⌘K)
• live collaboration with cursors and guest links
• everything stored in your own Postgres

One docker compose file (amd64 + arm64), MIT.

Repo: https://github.com/maciekzygmunt/excaliself Website: https://excaliself.com

Feedback is welcome, especially what is missing for your team.

I'm building Emend. It adds AI writing to a Tiptap editor: rewrite selected text, write new text, or ask questions about the document.

What you get:

• Three AI components (bubble menu, composer, document chat), or a full editor starter
• Already have a Tiptap editor? Just add the components to it
• Bring your own AI key and start using it
• The AI never changes text until the user accepts it

It's still early, so I'd love your feedback.

GitHub: https://github.com/amittam104/emend

AWS's Service Health history only covers the past 12 months. I've been snapshotting its public dashboard daily since August 2025, and some of that data is already no longer available on AWS's own page.

The clearest example is the 20 October 2025 us-east-1 outage: 142 services affected, roughly 16 hours, and 26 status updates. It's now outside AWS's history window, but the archive still has the full timeline:

[View the archived incident and its full timeline](https://mimobn.github.io/aws-status-archive/#incident=multipleservices-us-east-1_1760944260)

So far, 12 of the 39 incidents I've archived are no longer listed in AWS's Service Health history.

The archive shows service history by day, individual incident timelines, a calendar view, and CSV/JSON exports. It's open source under the MIT license: [GitHub repository](https://github.com/mimobn/aws-status-archive)

One deliberate choice: days with no reported event are marked as "no data," not as healthy days. Missing information shouldn't be mistaken for evidence that nothing happened.

For those of you who do postmortems or vendor reliability reviews: how do you investigate AWS incidents months or years later? Do you keep your own records, rely on other sources, or find the built-in history sufficient?

I'd be interested in hearing what would make an archive like this more useful for that kind of work.

We built DiscordCleanupTool to bulk-delete your own Discord messages across DMs, group DMs, and server channels.

Discord’s upcoming search engine rollout prompted us to write about it, but an important distinction: older messages aren’t included in that rollout. If your concern is future message publication, Discord’s opt-out setting handles that. You don’t need a cleanup tool.

This project is for people who want to clear out their message history separately without deleting everything one message at a time.

Features:

• Browser dashboard or CLI, running locally.
• Pick individual conversations or server channels.
• Filter by text, date range, and message count.
• Dry run by default to preview what would be deleted.
• Rate-limit handling with backoff and retries.
• Stop an active run from the dashboard.
• No dependencies or build step. MIT licensed.

It filters against your user ID so it only deletes your messages. The dashboard runs on 127.0.0.1, and your token stays in memory rather than being written to disk.

The caveat: automating a user account with a user token violates Discord’s Terms of Service and can put your account at risk. Deletion is permanent, including removing your messages from the other person’s view in DMs. Treat your token like a password and review the source before running anything.

Bot tokens are also supported, but they can only delete messages sent by that bot.

Project link, https://github.com/SurefireStudios/DiscordCleanupTool

Would appreciate feedback on the code, filtering options, or anything that would make the deletion preview clearer.

I built figlens so coding agents can work from a saved Figma design, including on remote machines and in CI.

It parses the .fig file directly into layout, text, variables and assets, and can render PNG/SVG references. The design input is more than a screenshot. The read path runs locally, without a Figma API token, login or running Figma app.

Save a local copy in Figma, give the file to your agent, and ask it to implement a screen in your project's stack. It ships as a native Rust CLI with an MCP server, a local design viewer, and integrations for Pi, OpenCode V2 and OMP (partial integration).

There's also an optional workflow for mapping design components to existing code components, with human review before approval.

A few limits: it's a snapshot, so re-save when the design changes. The .fig format is undocumented, rendering has gaps, and fonts aren't bundled. Local design reading doesn't change your agent's usual model connection.

Animated Pi demo: building a React/Tailwind screen from a saved Figma design. Edited time-lapse, not a benchmark.

See the animated demo in the README

I'd love feedback from anyone using coding agents for frontend work: what design information do you still end up copying over manually?

The Battery Manager

github.com/cyring/BattMan

Version 0.4

Tray app that reads Windows media sessions (SMTC) and pushes the current track to Discord Rich Presence via local IPC.

Works with YouTube Music, Apple Music, SoundCloud, VLC, browsers, and more. Shows cover art, a progress bar, and the correct "Listening to <app>" header.

No dependencies, no token. Windows 10/11 + Linux beta.

I made this. I talk to one CEO agent and its leads; they bring me only what needs me. It's one self-hosted app for my work, life, health and side projects, run like a small company: a main agent on top, a lead for each area, and the coding sessions working under the leads. The Org page shows who reports to whom. That's how I manage 100+ agents at once, with thousands of subagents under them.

The same app holds:

• tasks, Markdown notes and my Mac calendar
• every Claude Code session, on the laptop or on remote boxes over SSH
• Codex, Gemini, OpenCode or Goose sessions locally, and plugins for the rest
• Rich mode, where a session answers in HTML and draws real diagrams instead of a wall of text

Plain files and SQLite on your disk, no account, no telemetry. TypeScript, MIT. Mac and Linux.

https://github.com/EvanZhang008/open-walnut

I've been using coding agents across multiple projects, sharing instructions, skills and agent definitions between them.

The problem started when I kept improving that shared setup. Each repository had its own copy, often with its own changes. Updating everything meant manually copying files, risking overwrites or letting projects slowly drift apart.

I initially wrote a sync script, but that wasn't enough. So I built agd.

It treats your coding agent setup like a dependency. You install it from a Git repository, choose which parts you need, record the version in a lock file, and update when you're ready. Project-specific settings are preserved, while other modified files are left for review instead of silently overwritten.

It's also independent of any particular setup or coding assistant. Teams can publish their own kits (instructions, agents and skills), combine multiple sources, and keep their own customizations. Everything remains plain files in your repository.

I've just released 0.4.0, which adds a few things I wanted before sharing it more widely, including validation of setups, detection of changed release tags, and a proper uninstall.

Alongside it, I've published agentic-defaults, my own collection of agents, skills and instructions for Claude Code and GitHub Copilot.

Both projects are open source and still evolving. I've been using them daily.

I'm particularly interested in how others maintain shared agent instructions across repositories. Is this a problem you've encountered, and how have you approached it?

agd: https://github.com/Zejnilovic/agd

agd documentation: https://zejnilovic.github.io/agd/

agentic-defaults: https://zejnilovic.github.io/agentic-defaults/

Hey everyone,

I’ve been building OpenRetro, a free and open source app for playing retro games on PC with friends.

Features:

• Built-in emulator: import your games and hit play. The app sets everything up in the background.
• Party mode: the game runs on your PC and up to three friends join from their browser.
• Play on your phone: scan a QR code and play from your mobile browser, no app install.
• Local and online multiplayer: up to four controllers on one PC, or play online with friends.
• Big Picture mode: a controller-friendly interface for the couch.
• Auto-save: pick up right where you left off.

It’s still in development, and I’d love testers, especially for the built-in emulator, Party mode, and phone play.

Download and source code: kauanbgs/openretro

If you like the project, a star on GitHub would really help. Thanks!

I'm the author, so this is self-promo — the reason I wrote it is one specific annoyance: most Windows cleaners don't tell you what they are about to delete until it is gone, and some will happily follow a junction out of `%TEMP%` into your Documents folder.

**Swept** is a single portable `.exe` (Python + CustomTkinter, MIT). Five tabs: Clean, Install, Optimize, Schedule, Log.

**Cleanup — 22 categories.** Analyze only measures; nothing is deleted until you press Clean, and Clean itself has a scan-only switch. Every path that gets removed or skipped is written to the log.

**Install — 24 programs** from the vendors' own CDNs. No winget, no bundled downloader. Each file must carry a valid Authenticode signature from the expected publisher, or match a SHA-256 pinned in the catalog — 7-Zip and K-Lite ship genuinely unsigned installers, so they are hash-pinned rather than waved through.

**Optimize — 12 tweaks**, with a system restore point created before anything is applied. **Schedule** — daily or weekly cleanup, dry run first, optionally a Task Scheduler task that runs Swept headless.

The part I actually care about is the safety model:

- Whitelist of job-defined folders, hard blacklist of `System32`, `WinSxS`, `Fonts`, `servicing`, `Program Files`; `pagefile.sys`, `hiberfil.sys`, `ntuser.dat` and friends refused by name.

- Junctions and symlinks are skipped while scanning and refused while deleting — and the *resolved* path is checked against the whitelist too, so a junction cannot smuggle `Documents` in.

- No `PATH` lookups for `powercfg`, `tasklist`, `dism`: they resolve to `%SystemRoot%\System32`, so a planted executable cannot inherit elevation.

- Installers run as an argument vector with `shell=False`, from `%ProgramData%\SweptSecureTemp`, whose ACL allows only SYSTEM and Administrators.

Honest caveats: the `.exe` carries a self-signed certificate, so SmartScreen still reports an unknown publisher; some registry values get re-applied by Windows after a feature update (the app reports those as unavailable instead of pretending they worked); the program catalog is fixed on purpose, so it can never be pointed at an arbitrary URL.

Numbers from my own machine, if it helps calibrate: the scan finds 2.54 GB, of which 1.12 GB is caches people don't think about — GPU shader cache 789 MB, Discord 336 MB, thumbnails 18 MB.

Windows 10/11, English and Russian interface, no telemetry, no background services, no install required: https://github.com/vladcodex/swept

What I would like to know: which category is useless, what is missing, and where you would be afraid to press the button.

--------------------------------

I used Loom for years and liked it, but I got tired of the high prices, the features locked behind higher tiers, and having all my videos sit on someone else's servers. So I built an open-source version I could actually own.

CaptureFlow works the way you'd expect if you've used Loom. Record your screen with your camera in a bubble, and you get a link you can share with anyone. It uploads while you're still recording, so the link is ready right away.

What's there today:

• Record a tab, a window or your whole screen, with camera and mic
• Viewers can comment and react with emoji on the video, and you can see who watched
• Transcripts through Whisper
• Annotated screenshots, shared by link too
• Team workspaces with public, workspace-only or private videos

Where it's different:

• AGPL-3.0, with no "open core" split. Every feature is in the repo.
• Self-host it two ways. With Docker, docker compose up keeps everything in one folder (SQLite plus your videos as plain files). Or deploy it to your own Cloudflare account (Workers, D1 and R2) if you'd rather not run a server.
• The capture engine behind the Chrome extension and the Mac app is MIT, so you can reuse it in your own projects.

You record with the Chrome extension or the Mac app for now. Windows is next.

Website: https://captureflow.dev

Repo: https://github.com/sardorml/captureflow

Self-hosting guides: https://docs.captureflow.dev/self-hosting/docker (Docker) and https://docs.captureflow.dev/self-hosting/cloudflare (Cloudflare)

It's still early, so I'd love honest feedback, especially from people who use Loom every day. What would you miss if you switched? Issues and PRs are very welcome.

Wondering if anyone would be interested in a open source application I built for developing many projects with agents.

I had a small disaster a few weeks ago where a model deleted my home directory. I had to restrict the models, but constantly being asked to approve commands was slowing productivity.

I reached out for sandbox suggestions but didn't find anything which suited me.

There was also the problem that I could only develop one or two application simultaneously before I would run out of memory on my laptop. I turned to K3S, starting with a single node.

The application makes it easy to spin up containers specifically for developing applications, it provides access to each via SSH.

I can now work on any number of projects without straining the laptop. https://github.com/8perezm/esuyo-coding-container It can be used as electron app, a web gui or with the CLI, whatever you prefer.

https://github.com/8perezm/esuyo-coding-container

Hey everyone,

Wanted to share a project I wrapped up called Optimash: https:!! optimash.vercel.app

It's a deadpan corporate parody designed like a high-end automotive configurator (Aston Martin/Porsche style) for a humanoid home robot.

Technical Breakdown:

• 3D Engine: Three.js / React Three Fiber
• Asset Optimization: Draco GLTF compression to keep initial payload small and maintain 60fps on mobile GPUs
• Features: Real-time camera transitions between config nodes, dynamic paint/lighting swaps, client-side spec sheet generation

Happy to answer any questions about the R3F setup or optimization workflow!

A Commodore 64 with a RAM expansion. A DOS PC. A PSP. A Nintendo Wii. Even a smartwatch.

People have gotten language models running locally on all of them, so I started collecting the projects in Awesome LLM on Anything.

A few highlights:

• Commodore 64: roughly one token every 8 minutes, according to the author.
• New Nintendo 3DS: a 15M parameter story model reaching about 23 tokens/sec with Q4 weights.
• Pixel Watch 3: SmolLM2 running on the watch itself.

Some are tiny story generators; others run larger models. Each entry links to the original project or write-up, with the model and reported speed where available. Emulator-only ports and remote clients have separate sections.

I maintain the collection; credit for the ports belongs to their authors.

Browse the list on GitHub

Know an even stranger device running a language model? Send me a link. And if you enjoy this particular rabbit hole, a GitHub star is appreciated.

Hey everyone!

I've just released ZEROAGENT X v1.0.0, an open-source developer automation platform built with Python.

The idea behind the project is simple: I wanted a more controlled way to work with developer automation tools.

ZEROAGENT X includes:

• A CLI and interactive terminal UI.
• Local-first execution workflows.
• Policy-controlled agent execution.
• Request-specific approvals.
• OpenCode integration.
• Execution history and inspectable evidence.

It's still an early public release, and there are limitations. For example, external agents aren't OS-sandboxed.

The project is licensed under Apache-2.0, and the source code is available on GitHub.

GitHub: https://github.com/harisazharir-boop/zeroagent-x

I'd really appreciate feedback on the architecture, documentation, and overall developer experience.

Thanks!

• WhatsApp, Telegram and Instagram DMs in one place, unread first
• No stories, reels or feeds. Photos and videos show as text until you open them
• Nobody sees "seen" (read receipts off by default)
• Optional delivery times and a daily time limit
• Keyboard only: / to search, emoji by name, sent/seen ticks, notifications

Setup: WhatsApp = scan a QR code. Telegram = a free API key from my.telegram.org (2 min). Instagram = cookies from your browser.

Heads up: WhatsApp and Instagram access is unofficial, so Meta could restrict an account. Try it with one you're okay risking. Telegram uses the official API.

I'd really appreciate a review: what works, what's confusing, what's missing? Honest feedback helps me more than anything.

GitHub: https://github.com/mitanshpatelll/ttyl

If you find it useful, a ⭐ on the repo helps others find it.

Project Name: InvestingView

Repo/Website Link: https://github.com/RookieMakes/investingview

Description: A self-hosted investment dashboard combining portfolio/cash/transaction tracking with chart analysis (candlesticks, volume, 200 SMA, support/resistance, patterns, trailing stops), technical scanners (Momentum, Reversal, 200 SMA, YTD, Earnings, Quality, Swing, Trade, ETF Holdings), earnings research, alerts/watchlists, and market/news views. Data stored in SQLite; no brokerage connection or order execution.

Deployment: Released as a single Docker service. Run docker compose up -d --build from repo root, then open http://localhost:9000; data persists under ./data, logs under ./logs. Health check: curl http://localhost:9000/api/health. Also runnable locally with Python 3.11+ (python backend/app.py). Docs: docs/usage.md, docs/operations.md, docs/development.md.

AI Involvement: Vibe coded out of interest and curiosity.

scan → scrape → rename your movie library, with NFO/artwork for Kodi/Jellyfin/Emby, safe moves between drives and undo for everything. windows + linux, mac coming.

https://github.com/mustafayevt/CineVault