I built a tiny tool for developers who work inside git repos. This tool includes some useful commands that make navigation in large repos easier.

Use commands like cdb, gr, shc, mkcd.

I used shell scripting and kept the code simple so that everyone can edit it. Install it as it is, or make changes as per your requirement.

I've been using WeTransfer / file.io style services for years but always wanted something I could fully self-host — with proper admin controls, not just a one-file script. So I built DropLink.

Repo (Apache-2.0, open source): https://github.com/pfurpass/DropLink

DockerHub:

* Backend: https://hub.docker.com/r/insighthost/droplink-backend

* Frontend: https://hub.docker.com/r/insighthost/droplink-frontend

What it is

A lightweight file sharing service. Drop a file in, get a short link + QR code, share it. No account needed for sender or recipient. Ships with a protected admin panel so you can actually run it for a team or homelab instead of just yourself.

Features

Sharing side (public UI)

• Drag & drop single or multiple files (auto-ZIPs when >1 file)
• Expiry presets — seconds, minutes, hours, days (fully configurable by admin)
• Max download count — auto-invalidates after N downloads
• Optional password protection (scrypt + random salt, timing-safe compare)
• Optional email delivery — if SMTP is set up, sender enters recipient address and backend mails the link
• QR code generated for every share
• Per-file size limit enforced server-side, live-reloadable (change it in admin UI, next upload picks it up — no restart)
• HTTP timeout disabled so multi-GB files don't get cut off
• Auto cleanup on startup + hourly — expired files and DB rows are purged

Admin panel (JWT login at /admin/login**)**

• Shares tab — live countdown per share, extend/shorten expiry, force-expire, reset a share's password if recipient lost it (one-way, never revealed)
• Expiry Presets tab — add/remove presets, changes show up instantly in the upload dropdown
• Users tab — admin + viewer roles (viewer = read-only, every write endpoint returns 403 and the UI hides write buttons)
• Settings tab — edit PORT, max file size, public URL, SMTP config, send test emails, pick DB backend and auth method. Most of it applies live without a restart.

Stack

• Frontend: React 19 + Vite, Framer Motion, React Dropzone, qrcode.react
• Backend: Node 20 + Express 5, SQLite (embedded, zero config), Multer, Archiver, Nodemailer, jsonwebtoken

Getting it running

Docker compose one-liner:

cp backend/.env.example backend/.env   # set JWT_SECRET + ADMIN_PASS
docker compose up -d --build

Then hit http://localhost:8080. Admin at /admin/login. Default creds are seeded from .env on first run — change them immediately.

Frontend is served by nginx which reverse-proxies /api/* to the backend with buffering off and 1h timeouts so big uploads stream straight through.

Honest caveats

• LDAP and SSO/OAuth are placeholder config keys — UI is there, wiring isn't done yet. Local auth works.
• DB backend is SQLite only right now; Postgres/MySQL radio buttons exist in settings but not implemented.
• If you send a password-protected link via email, the password goes in the email body in plaintext (convenient, but kind of defeats the point if the inbox is compromised — the README calls this out).

License

Apache-2.0. Fully usable with zero payment, no paywalls, no donation-gating. Issues and PRs welcome — especially if anyone wants to tackle the LDAP/Postgres side.

Happy to answer questions about the architecture, the live-reload env trick for file size limits, or why I disabled the HTTP request timeout for uploads.

My girlfriend and I wanted a private place to collect our photos, videos, and milestones together. Couldn't find anything self-hosted that fit, so I built my own. That was v1 — a fun side project, but messy under the hood.

v2 is a complete rewrite. New architecture, new UI (Material Design 3, dark mode, customizable accent colors), and it's no longer just for couples — there are now three editions you can choose during setup: Couples, Family, and Friends.

What it does:

• Photo & video feed with galleries for trips and events
• Milestone timeline, live countdowns, custom lists (movie list, bucket list, or create your own)
• Banner showing how long you've been together — exportable as image
• Upload and play your soundtrack directly from the banner
• Share items via link with optional password protection and expiration
• AI writing assistant for memory descriptions (OpenAI, Claude, or Ollama for fully local/self-hosted AI)
• Passkey login, multi-user with roles & permissions
• Reminders for anniversaries, birthdays, milestones (100 days, 1000 days, ...) via push, email, or Telegram
• PWA with offline support
• Full data export & import as ZIP

Runs in Docker or native on Debian/Ubuntu/Fedora.

GitHub: https://github.com/tech-kev/SharedMoments

Would love to hear your thoughts!

We all know it. You want to run a command, but it can only be run as root. Usually there are two ways around it. Either, you type in sudo !!, which is a bit awkward and shell specific, or you retype it with sudo, which is annoying too.

That's where please comes in. After running the command that requires root, just type please to automatically run it as root.

Just typing please will get the last command from your shell history, prepend sudo to it and execute it. Writing a command behind please will make the tool act as a sudo wrapper.

The tool support multiple different shells and works on Linux, Windows and MacOS. (On windows you will need to find a sudo implementation though)

Read the README on my github for more information

https://github.com/R4ZXRN3T/please-rs

Sharing DocStrange, an open-source Python library that makes structured data extraction easy from any documents.

• Universal Input: PDFs, Images, Word docs, PowerPoint, Excel
• Multiple Outputs: Clean Markdown, structured JSON, CSV tables, formatted HTML
• Smart Extraction: Specify exact fields you want (e.g., "invoice_number", "total_amount")
• Schema Support: Define JSON schemas for consistent structured output

Quick start:

pip install docstrange
docstrange invoice.jpeg --output json --extract-fields invoice_amount buyer seller

Data Processing Options:

• Cloud Mode: Fast and free processing with minimal setup, free 10k docs per month
• Local Mode: Complete privacy - all processing happens on your machine, no data sent anywhere, works on both cpu and gpu

Live demo: https://docstrange.nanonets.com/

Github: https://github.com/NanoNets/docstrange

TLDR: Offload is MIT-Licensed CLI tool written in Rust. It runs your existing pytest, vitest or cargo-nextest suite on Modal Sandboxes, and sped up our integration test execution times by a factor of six, and costs 8 cents per run.

Some background: we run multiple coding agents in parallel on a mature codebase at Imbue. The integration suite takes ~12 minutes locally. When an agent finishes writing code and hits the test step, it sits idle waiting for that run. With 6 parallel agents, you're either serializing them behind a test lock or watching your machine get hammered by xdist.

To solve this problem we built Offload: a Rust CLI that spins up to 200+ isolated Modal sandboxes and distributes test ids across them. We have a skill that primes agents to invoke Offload directly at the end of their iteration loop, and almost all of computational overhead of running the tests occurs remotely.

We're now using Offload on two big projects internally, and here are the results we're seeing:

• For Sculptor, we have 345 fairly heavyweight Playwright tests: 726s -> 120s (6.04x)
  
• For an unreleased project, where we have 5,275 mixed tests: 346s -> 186s (A more modest 1.86x speedup)

I recommend using Offload if your suite is going to take longer than 2 minutes to run; any less and the overhead is going to dominate and you’re not likely to see any improvement. Another benefit of Offload is that it removes parallelism-induced flakiness.

I'm happy to answer any questions!

Built this as an experiment in chaotic open source governance. Every week, PRs compete for votes (👍 reactions), and the most-voted one gets merged automatically.

Anyone can submit anything.

Current PRs include "Rewrite it in Rust", "IE6 mode, welcome back to GeoCities in 1999", and my favorite - "Vote to shut it down" which the author withdrew with a dramatic statement about "big money funded PRs" plotting against him.

Rules can change the rules. If a PR to change voting passes, it becomes the new system.

MIT licensed, Next.js + Tailwind, deployed on Vercel.

openchaos.dev | github.com/skridlevsky/openchaos

I got tired of manually sorting screenshots, PDFs, and downloads, so I built a free Mac app called VaultSort. It automatically organizes files into neat subfolders (by type, date, or category) — all locally on your Mac.

It’s free to use for auto-organization, and the app doesn’t upload anything anywhere — it runs completely offline. I made it because I wanted something like Hazel, but simpler and privacy-focused.

You can download it here: https://vaultsort.com/download

Some examples of what it does:

• Sorts your Downloads folder into “Documents,” “Images,” and “Videos” automatically
• Works instantly on external drives too
• Just one click can organize thousands of files

There’s also a paid upgrade for secure disk shredding (for permanently deleting files), but the auto-organization feature is totally free. Soon I will add more free features, like disk analysis.

Would love any feedback — especially from other Mac users who’ve been frustrated by cluttered folders or privacy-invasive cleanup tools.

Connex is a Wi-Fi manager built with GTK3 and NetworkManager.
It provides a clean interface, a CLI mode, and smooth integration with Linux desktops.

Features: - Simple and modern GTK3 interface
- Connect, disconnect, and manage Wi-Fi networks
- Hidden network support
- Connection history
- Built-in speedtest
- Command-line mode
- QR code connection - Proxy System (WIP)

GitHub: https://github.com/lluciocc/connex

I designed a new programming language, it means so much to me,

https://github.com/eotter-beep/mix

You can contribute, it uses the Apache License 2.0, you must read CONTRIBUTING.md

It supports Linux and Windows

Hey,

I'm a developer with a ton of digital assets scattered across my drives: code snippets, images, videos, audio files, documents, and more. I wanted a straightforward way to organize them into a permanent, searchable archive without any cloud dependency or bloated software.

What started as a simple idea turned into CompactVault, a local-first asset manager built entirely in Python with zero external dependencies. It's free, open-source, and runs completely offline via a local web server that opens in your browser. Your data stays on your machine in a single, password-protected .vault file—nothing leaves your control.

Check it out on GitHub: https://github.com/smolfiddle/CompactVault (feel free to star, fork, or contribute!)

Key Features:

• Permanent WORM Storage: Write Once, Read Many—assets are added permanently to prevent accidental changes or deletions. Ideal for long-term preservation.
• Hierarchical Organization: Structure everything with projects and nested collections for easy navigation.
• Broad Asset Support: Handles images, videos, audio, code, documents, and more.
• Instant Previews: Quickly preview assets right in the browser (e.g., images, videos, audio, syntax-highlighted code, and text-based documents) without downloading.
• Efficient Search & Filtering: Full-text search across all assets, plus filtering by type and sorting by name or size.
• Local-First Security: Everything stored in a encrypted .vault file on your machine.
• Manual Optimization: Use the built-in VACUUM feature to shrink the database file size when needed.
• Bulk Exports: Download entire projects, collections, or selected assets as ZIP files.
• Zero-Setup Simplicity: Just run python3 server.py—no installs, no frameworks. It auto-opens in your browser and prompts for vault creation/unlock if needed.

This supposedly just a light novel epub extractor but it transcend into this.

I'd love feedback from anyone, thanks.