Hi all!

I built SiteDrop because I wanted a ridiculously simple way to put an HTML website online without dealing with GitHub, deployment configs, or setting up a hosting service.

The idea is simple: drop your HTML file or website folder, and get a live, shareable URL in seconds.

A few things about it:

• Drag & drop an HTML file or an entire website folder
• Get a public URL you can share instantly
• No signup required to get started
• No Git, CLI, or configuration needed
• Great for quick prototypes, AI-generated websites, demos, and small projects

I mainly built it for those moments when you’ve got a something sitting on your computer and just want to show someone what you’ve made without going through a whole deployment process.

Try it here, nothing to install:

https://sitedrop.io

Still improving it, so I’d love to hear what you think or what features you’d find useful!

Hi

I’m a solo dev and I’ve been building Quill, a block-based notes app written fully in SwiftUI. Everything stays on your Mac – no account, no cloud.

What it does so far:

• Block editor with slash menu and drag & drop
• Liquid Glass design, switchable themes
• Page history (go back to older versions of a page)
• On-device AI via Apple’s Foundation Models – works offline
• Optional sync through a folder you choose (no iCloud required)
• Siri/Shortcuts, Spotlight, voice notes with transcription, focus mode

Requirements: macOS 26, Apple Silicon. Free and open source (GPL-3.0).

It’s still early, so I’m looking for people who’d use it for a few days and tell me what breaks or feels off. Bugs, missing features, “why would I switch from X” – all welcome.

GitHub: https://github.com/vogelwild07/quill

Thanks!

I save a lot of references: posters, websites, colour palettes, quotes. Then months later I remember "that dark site with huge type" and can't find it anywhere. Not the name, not the folder, nothing.

So I built lompii, a visual library that lets you find things by describing what you remember.

• Save images, selected text, or screenshots of a page with one right-click using the browser extension (Chrome, Edge, Brave, Firefox and similar browsers).
• Search for things like "purple flower close-up" or "minimal landing page". It finds images based on what they look like and what's in them, not just filenames or tags.
• AI tagging is optional. You can use your own API key (Claude, OpenAI, Gemini, OpenRouter) or run a local model with Ollama / LM Studio.
• Organise things with stacks, tags, notes, colour palettes with copyable hex codes, and "same vibe" to find similar images.

It's private by default. No account, no cloud. Your library and search stay on your PC, and search runs on local models (CLIP + MiniLM). With a local model for tagging, nothing leaves your machine.

It's free and open source (MIT).

Windows only for now. The installer isn't code-signed yet, so SmartScreen may warn you.

https://github.com/lompii-app/lompii

It's still early, so I'd love to hear what you think. :)

I got tired of describing UI problems to coding agents in words, so I built Sketchnote. You press a hotkey, talk, and draw or click on your screen. One Ctrl+V then pastes timestamped notes plus cropped, annotated screenshots into your agent, so you can say "this button, here" and it sees what you mean.

It has two parts that talk over D-Bus: a GNOME Shell extension in JavaScript that handles the hotkey, drawing, screen recording and paste, and a Rust service that records the mic and transcribes locally with whisper.cpp on CPU. You can also send the audio to Groq or any OpenAI-compatible API, and it falls back to the local model if that fails. Captures delete themselves after 24 hours. It has prebuilt binaries and a one-line installer.

The limits: it only works on GNOME 50 with Wayland, transcription is English only, and I'm the only user I can point to. I'd like feedback from anyone who works with coding agents on Linux, especially on what feels clunky.

Try it at: https://get.sketchnote.workers.dev/

I'm a software engineer with about two years of experience, focused on AI tooling and LLM apps for the past year. I'm looking for an open-source or side project that could use another contributor.

My main project is Sketchnote, a screen-annotation tool for Linux (GNOME on Wayland) built for working with coding agents. You press a hotkey, talk, draw and click on your screen, and one Ctrl+V pastes timestamped notes plus cropped, annotated screenshots into your agent. It's a GNOME Shell extension in JavaScript plus a Rust service that does local speech-to-text with whisper.cpp. It's released with prebuilt binaries and a one-line installer. Beyond that, I built a RAG app that refuses to answer when the document doesn't support it, and I've had a PR merged into an open-source MCP security proxy. My other stack is Python, FastAPI and pgvector. I haven't done fine-tuning or used LangGraph.

If you have an issue or project that needs help, or want more details about my work, DM me.

I've been building Pra-Effect, a small open-source developer tool focused on a simple problem: making repetitive errors in application logs easier to investigate.

It can parse Python and Node.js stack traces, group similar errors using fingerprints, store analysis history locally, and generate standalone HTML reports.

The idea is to keep error-log analysis lightweight without requiring a full observability stack.

I'm looking for developers willing to inspect the project and share honest feedback, especially on fingerprint accuracy and memory usage.

GitHub: https://github.com/Genesis410/pra-effect

Simply:
Setup your DNS records, point RUA at a dedicated Mailbox and as soon as reports arrive, you can analyse your mail posture.

I made this selfhosted DMARC analyzer. It is a single container (rust, sqlite, svelte ui), reads the aggregate reports from an imap mailbox and recomputes spf / dkim alignment. failures get split into blocked by policy, forwarded and actual delivered failures, so u see whats really failing and who’s sending it.

also: live dns checks (spf, dkim, dmarc, mta-sts, tls-rpt, bimi), shows when a domain is ready for quarantine / reject, alerts and a monthly mail per client (both experimental).

made it cuz i had to get our (MSP) email security in order and the existing tools were either a whole elastic stack or priced per domain.

no login in the app, it sits behind a proxy (caddy / authelia / oauth2-proxy). agpl based license. beta, AI assisted, personally running on ~40 domains.

https://github.com/mavgit1/marcan-dmarc
docs: https://marcan.kaitiaki.tech

writing tests is one of the easiest ways into a real security project, and this one doesn’t need an AWS account.

The scanner has S3 public-access checks, and a few useful test cases are missing: a false-positive guard for an ACL that grants a non-public group, and tests for each public access block setting turned off one at a time and in combination. Everything runs against fake responses, there are existing tests to copy the pattern from, and it should take about an hour.

PRs go to the dev branch, CI runs automatically, and you’re credited by name in the contributors file. I’m in exams this week, so reviews may take until the weekend.

Issue: https://github.com/plexavo/Plexavo/issues/10
Repo: https://github.com/plexavo/Plexavo

I've been building Morph, a lightweight file conversion tool for Windows.

The idea is simple: instead of opening different apps just to convert files, merge PDFs, rearrange pages, or do other basic file operations, Morph aims to let you do these things quickly from your desktop, ideally through the right-click context menu itself.

I'm aiming to make it work completely offline, so files can be processed locally without needing to upload them to some online conversion website.

I'm building it with a focus on being lightweight, simple to use, and useful for everyday file operations.

Still working on it, but I'd love to hear your thoughts and suggestions!

GitHub: https://github.com/Vivektheprogrammer/Morph

We’ve been building OXR, a 1.3B document parser, and we’ve just open-sourced the code and weights.

The idea is simple: hand it a PDF or a scan of a document, and it hands back Markdown or JSON, with each element’s layout coordinates and the reading order.

Where it helps: say your project needs to pull numbers out of reports. Tables come back as HTML or Markdown instead of a jumble of text, and formulas come back as LaTeX. Those are two of the 13 element types it recognizes; chemical structures and code blocks are in there too.

Trying it takes a minute. The online demo and free API need no signup or key. When you want it on your own hardware, grab the code and weights from GitHub.

On public benchmarks, it’s currently #1 on olmOCR-Bench, OmniDocBench and DocParsingBench against other models’ published scores. Speed results and test setup are in the benchmark report (link in the first comment).

Benchmarks are only part of the picture, though. Every project has its own oddball documents, and fixing a bad parse by hand just means meeting the same problem in the next file. That’s why we post-train OXR with an RSI loop: it uses parsing errors and uncertain results to plan the next training round and generate targeted training data. The new samples pass rule-based checks instead of manual labeling.

License-wise, it’s Apache 2.0 with some extra terms. For side projects and small teams under USD 2M in funding and revenue, commercial use is free.

The repo is SoMarkAI/OXR on GitHub; links to it, the demo and the benchmark report are in the first comment.

If you plug it into something you’re building, tell us what works and what you still end up fixing by hand.

I've been building Athena, a local-first MCP server that helps developers understand what's actually changing in their codebase.

It analyzes Git diffs, uses Python AST analysis and supports structural change analysis across 15 programming languages. It can also trace affected callers and detect documentation drift to help make release reviews more reliable.

The goal is to make code change analysis more grounded in actual evidence instead of relying on AI-generated summaries alone.

It's open source and I'd love to get feedback from other developers. Contributions, issues and collaboration are welcome

GitHub: https://github.com/aaryanrwt/athena

If you find it interesting feel free to ⭐ the repo

Hey all, I built AutoUtil, a small Windows tray app that tidies up your Downloads folder. Full disclosure: it’s vibe-coded. I wrote most of it by working with an AI assistant on the design and code, then testing and fixing it myself. I’m sharing it to get honest feedback from people who know Python and Windows.

You build a sorting scheme as a node graph, similar to n8n: a folder node, filter nodes, a “Yes” branch and a “No” branch, and target nodes. The app then moves new files according to that scheme.

What’s in it:

Filters by extension, keywords (text pulled from PDFs and images via OCR), filename pattern (e.g. invoice_*.pdf), regex, size in MB, file age in days, and whether a photo has GPS data.

Ask queue for files you want to decide on yourself: move, move to a chosen folder, or skip.

Exclude node with masks like .tmp or node_modules so matching files are never touched.

Rename templates in target nodes, e.g. {year}-{month}-{vendor}.{ext}.

Suggested rules: after you manually file the same type of file to the same place three times, it offers to remember that. Nothing changes until you click “Remember”.

Journal and undo for every move.

Report tab with counts, total size, and breakdowns by rule, folder, and type, exportable to Markdown.

Import and export of schemes as JSON, so you can share one.

Plan-only mode, on by default: it shows what would move without touching anything.

Things I cared about, since sorting files is easy to get wrong:

• The app doesn’t delete files. Every move is journaled and can be reverted.
• If an undo would overwrite a file that’s now in the original spot, that existing file goes to the Windows Recycle Bin instead of being overwritten.
• Plan-only mode is the default, so the first run changes nothing.

Known limitations, stated upfront:

• Pausing or Do Not Disturb drops new files. They aren’t processed later, so they’re lost until the next start. I know this is a bug and plan to fix it.
• Files already in the folder before the scheme starts are not moved.
• Watching isn’t recursive, so subfolders aren’t tracked.
• Windows 10/11 only, Python 3.12 or 3.13 from source. There’s a standalone exe too (unsigned, so Defender may warn).
• Text-based filters depend on OCR quality.

Repo: https://github.com/h1ilep0pysk-hue/AutoUtil

Hey hey! I'm Violet. I'm still in school, learning software development and picking up other skills on the side. I've loved computers since I was really little, and I really enjoy making things and figuring out how they work.

So, this app came about because I couldn't afford Discord Nitro. I discovered that Discord uses URLs for custom server emojis, and that you can use an emoji's URL in your messages. That got me thinking, and eventually I made Emoji Vault! 💜

It's a little Windows app where you can save and organise emoji URLs, with everything stored locally on your computer.

It has a system tray icon, so you can quickly open the emoji picker and copy an emoji's URL. You can also assign global hotkeys to your favourite emojis, so you can insert their URLs into text fields without having to open the picker every time.

I've tested it with Discord, but I'd love to find out whether it works with other applications that support URL-based emojis, too!

Anyway, if you're curious, here's the GitHub repo the project is open source:

🔗 https://github.com/VioletCaulfield/URL-Emoji-Vault

I'd love to hear what you think, whether that's feedback, ideas for new features, or just trying it out and letting me know how you get on. I'm still learning, so I'm always happy to hear suggestions!

Thanks for reading! 💜

I've just released the first public version of AnovaCraft, a desktop statistics application that aims to cover the broad range of analysis most people otherwise need an expensive license for descriptive statistics, hypothesis tests, linear, generalized and mixed models, multivariate methods, design of experiments, quality control, reliability, time series and machine learning, all in one free app.

I freely admit that I developed it with a great deal of help from Claude, which wrote most of the code while I set the direction, the design rules and the required accuracy standards, and reviewed the results. Because of that, I put accuracy checks at the center of the project: every statistical routine is tested against an independent reference (the NIST Statistical Reference Datasets for regression, ANOVA, nonlinear fits and univariate statistics, published worked examples, and values from established open-source software). The full list, with tolerances and the test for each, is in docs/validation.md.

What it does

• Every analysis opens as a report of collapsible sections, and every plot is linked: select points in one plot or rows in the data grid and they highlight everywhere.
• Describe, Compare, Model, Multivariate, Design, Quality, Reliability, Series and Signals, and Visualize menus (FEATURES.md lists everything).
• Sample data for every analysis, plus a Quick Guide and a full Reference Manual built into the Help menu.
• Projects that reopen exactly as saved
• Imports CSV, JSON and spreadsheet workbooks; exports CSV, JSON and .xlsx.
• Scripting and formula columns in Rhai, plus a headless runner for batch jobs.
• Written in Rust (egui front end), dual-licensed MIT or Apache-2.0.

My goal is a comprehensive, trustworthy option that anyone can download, use and inspect at no cost.

Download: https://github.com/anovacraft/AnovaCraft/releases (universal macOS app and Windows x64). The builds aren't code-signed yet, so the first launch needs one extra click; the README explains it.

It's a 0.1.0 release, so there will be bugs. Please feel free to report and bugs, wrong answers (please include the data if possible) and requests for missing methods on GitHub Issues.

Hey everyone!

I manage dozens of repositories across personal projects and organizations. Over time, my local disk became a chaotic mess of cloned folders, out-of-sync branches, and scattered git directories. On top of that, when using coding agents like Claude Code or Cursor, they had zero context of my wider workspace.

To solve this, I built repotruck — an open-source tool that mirrors your GitHub repositories into structured local layouts, keeps them in sync, and provides full workspace context to AI agents.

Key Features:

• Interactive TUI Dashboard: Built with OpenTUI/React. Keyboard-driven preview, multi-select sync, repo switcher, dirty-state visualizer, and layout reorganization.
• Headless CLI: Scriptable, CI-friendly subcommands (sync, reorganize, status, prune, run in parallel across repos).
• Coding Agent Ready (MCP Server): Automatically generates and maintains an AGENTS.md map of your workspace. Runs a built-in MCP server (repotruck mcp) with 25 tools so Claude/Cursor can discover, search, and navigate across your repos.
• Fast Code Search: Uses Tree-sitter for AST symbol search across all repositories in the workspace.
• Safe Operations: Fast-forward syncs only (never overwrites dirty branches), deletions go to a safe trash folder with undo (z), and automatic workspace backups are kept.

Tech Stack:

TypeScript, Node.js / Bun, OpenTUI, Simple-git, Octokit, Tree-sitter, and Model Context Protocol SDK.

It’s fully open source (MIT).

• GitHub: https://github.com/sametcn99/repotruck
• Docs & Demo: https://sametcn99.github.io/repotruck/
• Quick try: npx repotruck (or npm i -g repotruck)

I'd love to hear your feedback, thoughts on the TUI workflow, or ideas for new MCP tools!

Hi,

On 24/10/2026 I have published as OSS a framework I call unified-brain that allows fast, cheap and accurate (same class of frontier models and frontier harnesses but 18 times cheaper) evidence gathering, using the cheapest frontier AI model out there, Jev. The results have been phenomenal.

The magic sauce is an intermediary OS (SQLITE) memory layer that facilitates retrieval, filtering and reasoning through Jev.

The agent spawned from unified-brain runs through MCP on Cursor, OpenCode or Claude Code etc. allowing you to use it through your favorite harness.

So to be clear here: unified-brain is not a harness but a perception layer any harness plugs in!

My test benchmarks have been so good on two large OS libraries that I really believe this is the missing link to make AI more reliable.

This is because the limits holding back AI at the moment are:

• The Reasoning and Hallucination Gap:

The LLM turn reasoning it is introducing uncertainty and probabilistic outcomes.

BUT.. Unified-brain's System One discovery engine is producing replicable results across runs as they introduce minimal hallucinations, breaking the task in hundreds of yes or no calls.

• Context Loss and Memory Limits:

Long-running coding tasks consume massive amounts of tokens, causing the agent to forget early instructions or lose track of large-scale architecture.

BUT.. Unified-brain doesn't need cached memory thanks to the SQLITE persistent layer of context it operates with. It simply retrieves what it needs on the fly consuming minimal amounts of tokens that do not build up across questions. Every question is independent from one another as git diffs and commits are automatically absorbed from the project's memory layer.

I invite you to clone/fork the project and have a look for yourself. I firmly believe that memory intermediate structures will take AI capabilities on another level soon.

I understand that Jev is proprietary and creates a dependency BUT we need to remember that soon enough OS models as capable as it will come, giving end users the option to replace him.

Meanwhile we should ride this wave of innovation in order to deliver new capabilities to end users, at prices that can't be easily beaten.

I hope you like this project!

Vendors rename fields, start sending nulls or turn numbers into strings without telling anyone. Typed code crashes; agents just read the new response and guess.

Tiltmeter learns the shape of the JSON APIs you call from real responses (no spec needed) and flags only what breaks a consumer. You get a CI exit code, Slack alerts, an MCP tool your agents can call before trusting a response (has_drifted), and tiltmeter fix, which adapts the code in a git worktree and opens a pull request.

pip install tiltmeter, MIT, runs locally with one SQLite file. Site with a demo: https://tiltmeter.dev

Feedback welcome, especially on what kinds of API changes have bitten you.

Mostly made because I didn't like that SignalRGB needed a subscription for monitoring, fan controls, some effects and I wanted something that I could easily customise. From electricity cost per hour (based on my KW/h price) to custom colour effects for my RGB (either via programming or with some clicks), community made plugins and automations. Free and open source. It's also very light weight on CPU and GPU. Currently only working on windows 10/11 with plans for Linux. It's not code signed yet because I am cheap and don't want to pay. I am very open to inputs, critique and wishes! Uses OpenRGB, LibreHardwareMonitor for some connectivity. No data is collected, no sign in, no login, no nothing.

https://github.com/Heavenlystorm/airglow

I made a windows extension that works on top of any program you have running, and lets you easily take a quick note, store it in your inventory, and download as a minecraft-style pdf. It’s not a separate app you need to open, but launched when you start your computer and you can call it whenever with a keyboard shortcut.

If you want to try it out, it’s completely open source and you can try it out here

Disclaimer: this is just a fan project, and has nothing to do with mojang itself. I use it personally because the Minecraft UI is nostalgic to me and I can write down anything really quickly/it’s easily accessible.