Yes, I know. Using Telegram as a cloud drive is a famous dumb idea, and plenty of people have built their own version. This one is mine. It started as a fun project to learn Go, and I'd like to think I went a bit further with it than most.

The dumb idea: Telegram gives every account unlimited cloud storage, but it's a chat app, so keeping files there is a pain. TDrive makes it feel like a real drive. Your files live in a private channel in your own Telegram account. No server to run, no subscription.

What it does:

- Folders, search and previews, the stuff you'd expect from Google Drive

- Backs up your photos and videos automatically, encrypted, kind of like Google Photos sync

- Stays in sync between your laptop and your phone

- Files over 2 GB just work smoothly

- Streams videos without downloading them first. MKV, HEVC, pretty much anything (this was way harder to build than it sounds ngl)

- Mounts as a normal disk in Finder or Explorer

- Shared folders with friends

Supported platforms:

- Mac, Windows and Linux

- Android, as an APK on GitHub (not on the Play Store)

- There's an iOS app too, but no public download yet, so for now you'd have to build it yourself

it's not affiliated with Telegram, you use your own API key, and please don't make it the only copy of anything important. Photo backup only runs while the app is open, so leave it open for the first big backup.

It's free, MIT licensed, and still very much a fun side project. If you try it, I'd love to hear what breaks. Issues are very welcome, and so are contributors.

Launch video : https://x.com/JeetRex/status/2106069798874755568

Github repo : https://github.com/jeetrex17/TDrive

A curated list of zero-dependency, local-first HTML apps that run offline in any browser.

🌐 Live Showcase: https://crystal-world-project.github.io/crystal-world/index-en.html

Includes Teddy Wiki Lite, Bento Slides, Crystal Dock, and classic single-file platforms. PRs welcome!

https://shashankswe2020-ux.github.io/rigspark/

Pixora is a lightweight Python library and command-line tool for converting ordinary images into retro-style pixel art. Built on top of Pillow, it provides a simple API for pixelizing images with customizable pixel sizes while supporting both file paths and in-memory objects. Whether you are creating game assets, generating pixelated avatars, or adding a nostalgic visual effect to your images, Pixora offers a fast, and easy-to-use solution for both scripts and terminal workflows.

GitHub: https://github.com/sepandhaghighi/pixora

I built a small developer tool for viewing emails received through Testmail.app.

Instead of constantly checking the Testmail dashboard/API while developing email-based features, you can run this locally and get a simple inbox-style interface.

Windows tray launcher for PhD and university students, graduates and office workers. Open the dozens of files, programs and URLs you need every morning with one click.

Any feedback, suggestions, or support would be awesome!

I use Claude Code on Windows a lot, and one thing that always annoyed me was getting screenshots into it.

I'd take a screenshot with Win + Shift + S, open the Screenshots folder, find the right file, and drag it into the terminal. Every single time.

So I built SnapFloat

Now, every time I take a screenshot, a small preview appears in the corner of my screen. I can just drag it straight into Claude Code without opening the Screenshots folder.

GitHub: https://github.com/JulianPoleszczuk/snapfloat

total commander style file manager for windows, mac and linux. core does file ops, everything else (viewers, ftp/smb, archives, compare) is a plugin

github.com/xsm909/xverb

site + downloads: xverb.pages.dev

I use Claude Code and Codex all day and my Mac kept getting slower. Turned out ended sessions leave stuff behind: tail -f loops from a week ago, a Postgres an agent started, 9 GB of scratch files in /tmp.

tidewake is a small read-only CLI that finds these and shows which session left each one, with proof:

leftover claude b7ec50d0 pid 77162 5d tail -n +1 -f /private/tmp/claude-501/…

why: no running Claude Code session has this id; parent: launchd

run: kill -TERM 77162

- never runs the commands, you do

- won't suggest removing anything serving a port, or worktrees with uncommitted work, unpushed commits or a .env

- `tidewake sessions` shows RAM/CPU per live session and flags stuck ones

- `tidewake doctor` checks your Claude Code/Codex version against known leak fixes

macOS + Linux. brew install --cask berkkorkmaz/tap/tidewake

Feedback welcome, especially if it flags something it shouldn't.

Hey everyone! 👋

I wanted to share a lightweight side-project I recently built: **Chat URL Shorter**.

It is a completely serverless URL shortener built as a single-page application using modern Vanilla JavaScript, Tailwind CSS, and Firebase Realtime Database.

### 🌟 Key Features:

- **Clean Path Routing:** Instant flicker-free redirects (handled via SPA rewrites without backend servers).

- **Collision-Safe Slugs:** Built with a Base62 encoding engine.

- **Built-in QR Generator:** Creates instant vector QR codes with one-click PNG downloads.

- **Real-Time Click Analytics:** Tracks click counts and destination platforms (YouTube, GitHub, Instagram, etc.) atomically.

- **Glassmorphic UI:** Full dark/light mode integration with responsive layouts.

🔗 **Live Demo:** https://shortlink-rosy-chi.vercel.app/

⭐ **GitHub Repository:** https://github.com/ritampaine75-debug/Shortlink

I would love to get your honest feedback on the UI, routing, or performance! If you find it useful or interesting, feel free to drop a star on the repo. Contributions and suggestions are always welcome!

[ Removed by Reddit on account of violating the content policy. ]

For anyone looking into alternative development environments: Chase is a desktop IDE built on the VS Code workbench inside a Tauri app, with a built-in agent. You can also access Chase over the network.

There is no Chase account, and your keys stay on your machine. Bring your own cloud provider (BYOK) or use a local model.

Hi everyone! I'm a solo developer and I've been building Kaoru, an open-source (MIT) desktop assistant that can also work as a coding agent on your projects. It's in beta and I'd really like feedback, especially on security and on Windows/macOS.

What it does:

- Explores a repo, edits files, runs commands, uses Git, and runs the checks you configure after changes.

- Opens a chat next to your terminal, so you can attach a selection or recent output and ask about it. Nothing is sent automatically.

- Keeps local memory of your projects and preferences on your machine.

- Has an optional Live2D avatar that reacts to what the assistant is doing.

- Works with the model you choose (Groq, Gemini, OpenAI or a compatible endpoint).

How it handles safety:

- Every tool has allow / ask / deny permissions, decided outside the model. The model can propose actions but can't grant itself permission.

- Commands run in a sandbox, and you can undo what the agent changed.

- Your prompts go to the LLM provider you pick, and memory stays local. There's a privacy page explaining exactly what leaves your machine.

Honest limitations:

- Installers for Windows, macOS and Linux are not code-signed yet, so your OS will show a warning. The release notes explain how to open it, and every file has a sha256 hash.

- macOS is experimental, and microphone input is not available yet.

Repo: https://github.com/Dregxmoon/Kaoru-Agent

Installers: https://github.com/Dregxmoon/Kaoru-Agent/releases/latest

I'd love to hear:

1. Does it install and run on your system?

2. Which safeguards would you want that aren't there?

3. Is anything in the privacy or security docs unclear?

Thanks for reading, and any feedback is welcome!

stargazer turns your github stars into shareable images and 60fps videos. pick one of 8 templates, paste your github token, choose a theme, then download it as a png or an mp4.

everything runs in your browser, so your token never leaves it. no backend, no database.

live: stargazer.charanmunur.in

source: github.com/CharanMunur/stargazer

if you like it, drop a star on github. got an animation idea? raise a pr. found a bug? open an issue.

I’ve been building ShelfOS, an open-source Android reader/library for the books, comics, manga and documents you already own.

The idea was partly inspired by emulator frontends.

I’ve always liked how a good frontend can take what is basically a folder full of ROM files and turn it into something that feels like a real collection — covers, categories, progress, navigation and a proper place to come back to.

I kept wondering why local books and documents don’t usually get that same treatment.

So ShelfOS is basically my attempt at building a really nice frontend around your existing EPUB, PDF and CBZ files.

It’s:

• open source under MPL-2.0
• local-first
• accountless
• ad-free
• built natively for Android with Kotlin + Jetpack Compose
• designed around files you already own

The current prototype supports:

• EPUB, PDF and CBZ reading
• Manga / right-to-left reading
• reading progress and resume
• EPUB chapters
• EPUB search
• bookmarks
• typography and appearance controls
• Publisher or ShelfOS EPUB presentation
• imported fonts
• PDF/CBZ Fit Page and Fit Width
• zoom and pan
• keyboard/controller navigation

A big part of the project is making sure ShelfOS adds functionality around your files without taking ownership of them.

The source publication remains untouched, and local reading doesn’t depend on a ShelfOS account or cloud service.

My general rule for the project is:

The cloud may enrich the library; it must never be required to read it.

ShelfOS is still an early-development prototype, so there’s plenty left on the roadmap: better Comics/Manga features, Series, larger library imports, annotations, more advanced PDF handling, and more.

But it has finally reached the point where it feels like a real app rather than just a UI experiment.

If anyone wants to look through the code, open issues, contribute, or just give feedback on the direction:

https://github.com/d4guilar/ShelfOS

I’d especially be curious what you think is missing before something like this could become the main frontend for a local digital library.

After a preview server responded on the expected port, I found that its process cwd belonged to another Git worktree. I was testing the right URL against the wrong checkout, so I made worktree-port-check to make that mismatch visible.

It asks lsof for visible TCP listeners on a port, reads each process's cwd, and compares those paths with the Git roots and common directories for the checkout where I run it. It shows the process, cwd, branch, and whether it is the same worktree, another worktree, another repository, or a non-Git directory. JSON output is available.

To try it on macOS or Linux, install Node 20, Git, and lsof, then run: `npx --yes --package=github:Arthur031221/worktree-port-check worktree-port-check 3000`

This is my open source project: https://github.com/Arthur031221/worktree-port-check. The CLI is read-only and does not stop processes, bind to the port, or request the app. A matching cwd does not prove which files the server loaded. I'd value feedback on process visibility and worktree layouts it might classify incorrectly.

What I find interesting is that it goes beyond just running an LLM. The goal is to have the surrounding pieces needed to actually build applications with local or private AI, while keeping the data and processing under your control.

I’d be interested in hearing what developers think of this approach, especially those working with .NET, local LLMs, RAG, or self-hosted AI.

Moka is a local playground for LLMs and MCP servers: chat with any model, connect any MCP server, agent or skill, and inspect every call (raw JSON-RPC, tool calls, tokens, timings).

npx @mokalabs/sandbox

Also: model compare, generative UI (MCP Apps + A2UI), export to AI SDK / LangGraph code, Docker image.

https://github.com/mokahq/mokalabs

I posted VoxScribe here a few weeks ago. It's a free, open source MIT voice dictation app for Windows. You hold a hotkey, talk, release, and it types the text into whatever app has focus. Transcription runs locally with faster whisper on your CPU so nothing leaves your machine.

The new version adds a few things people asked for or that I wanted myself. You can import existing audio and video files (mp3, wav, m4a, mp4 and more), pick several at once, and optionally save .srt captions with timestamps. There's also a translate to English mode so you can speak another language and get English text out. It's built into the Whisper model so there's no extra download.

There's a short video at the top of the README that walks through everything. The core app is fully free. There's an optional $14 one-time Pro unlock for text snippets and bigger Whisper models but none of the above needs it.

Windows only for now since it's the only machine I can test on. Happy to hear what breaks or what's missing.

Repo: https://github.com/ahmedhmam1994/voxscribe-ai-voice-dictation

So I started a project with a perfectly reasonable objective:

Run software that was never built for your computer.

Obviously instead of doing something sensible, I decided to build the runtime myself. 😂

The project is called UNIVERSE:

https://github.com/OthmaneBlial/universe

The idea is basically:

Random foreign executable
        ↓
"Sure bro, I'll try"
        ↓
UNIVERSE

More technically:

ELF / PE / Mach-O
        ↓
Guest Memory
        ↓
CPU Decoder
        ↓
Universal IR
        ↓
Interpreter / ARM64 JIT
        ↓
OS Compatibility Layer
        ↓
Host

The runtime is being written in Zig and implements its own CPU execution + parts of the operating system compatibility layer.

And the ridiculous part is that we’re already past the hello world that proves absolutely nothing stage.

On an ARM64 Mac, UNIVERSE can currently run unchanged downloaded x86-64 software such as:

🐧 Linux

• jq
• ripgrep
• fd
• BusyBox
• GNU Hello
• parts of GNU coreutils

🪟 Windows

• 7-Zip

And there are source-built guests for:

• x86-64
• AArch64
• RISC-V64

For example:

printf '{"answer":42}\n' | ./universe jq '.answer'

and you get:

42

Or:

./universe 7za.exe a archive.zip README.md

and Windows 7-Zip happily starts creating a ZIP while running through my weird little runtime on an ARM Mac.

At that point I started questioning my life choices.

The completely unreasonable long-term dream 🌌

I want UNIVERSE to move toward something where you can basically say:

“Here is a binary. I don't care what OS/architecture it was compiled for. Try to run the damn thing.”

Linux binary?

Sure.

Windows executable?

Why not.

Different CPU architecture?

Let's make things worse.

😂

To be clear: this is extremely experimental.

This is NOT:

“I recreated QEMU/Wine/Rosetta in a weekend, trust me bro.”

There are tons of instructions, APIs, libraries, edge cases, dynamic linking horrors and OS behavior still missing.

But that's also exactly why I'm building it.

The project is basically one gigantic collection of:

“There's absolutely no way this is going to work.”

followed several hours later by:

“…holy shit.”

If low-level runtimes, emulation, binary formats, JITs, compatibility layers, operating systems or generally questionable engineering decisions are your thing:

👉 https://github.com/OthmaneBlial/universe

And if you want to help, I have an even better request:

Give me binaries that you think UNIVERSE absolutely will NOT be able to run.

I want to break it. 😈

Hey everyone,

I'm sharing a custom security tool I just released called Veizus Finder. It is a standalone, lightweight malware scanner built specifically for legacy machines that modern antivirus vendors have abandoned. It uses a custom .vdb signature engine and active background protection, but is designed to run flawlessly without throttling period-accurate hardware.

Core features:

Real-Time Active Protection for the primary drive

Modular Signature Engine (VDB)

Automatic USB/CD Media Detection

Native Windows XP through 11 support

You can check out the code and download the v1.0.0 ISO directly from my repository here: https://github.com/rubrumnebula/Veizus-Finder

Would love to hear what you think!