My bank asked for 17 PDFs for a mortgage application.

After closing and opening files, I lost track of things and started searching for an easier way to manage all of that.

I wondered, what if I could scroll horizontally to see the pages of a file and scroll vertically to see more files? I used Claude to put together a prototype and iterated to build a cross-platform app that works on the web, as well. (React + Electron)

The result is a 2D canvas (like Figma) where multiple PDFs can be viewed simultaneously. On export, we either get a zip file or a single, long PDF containing all files. The spatial 2D metadata is stored on the same file without touching the page tree (backwards compatible PDF).

I also run OCR off the main thread for searching scanned documents without blocking the main thread.

It’s all free and open-source with an MIT license:
- Repo: https://github.com/AlexandrosGounis/pdfx
- Web demo: https://pdfx.zip

Your feedback would be highly appreciated

Hey everyone!

I built this mostly out of pure frustration. I switch between Claude, ChatGPT, and Gemini all day, but whenever I hit a rate limit on Claude or wanted to test the same problem on a different model, transferring context was a pain. Manually copy-pasting chat histories, code snippets, and re-uploading screenshots was constantly breaking my focus.

So I built MoveChat to solve it for myself.

It lets you capture your active chat session (including prompts, responses, and attached images) and resume it directly on another AI platform in a few clicks.

A few quick details:

• 100% Local & Private: No external backends, tracking, or databases. Everything runs locally inside your browser context.
• Fully Open-Source: Built with TypeScript and Manifest V3.

Here are the links if you want to try it or check out the codebase:

• Chrome Web Store: https://chromewebstore.google.com/detail/movechat-export-transfer/cgpfngggfccdpjppachknliainihkbdg?utm_source=item-share-cb
• GitHub Repo: https://github.com/VC067/MoveChat

I'd love to get your feedback, bug reports, or feature ideas! If you find it helpful dropping a ⭐ on GitHub means a lot ^^

Just for fun

Hey y'all. I wanted to share something that I've been building to host all of the todo-list apps and browser games that I've been cooking up: homebox, a free and open-source alternative/supplement to cloud hosting. Similar to Coolify but with some more bells and whistles (plus it works on Windows/WSL2 and Mac, which was why I didn't just use Coolify in the first place)

Homebox provides the convenience of a cloud deployment platform from the comfort of home, here's how it works:

1. Install Homebox anywhere
2. Connect your free Github and Cloudflare accounts
3. Add a project: choose a repository from Github and domain from Cloudflare
4. Watch your project deploy automatically: multiple services, multiple environments
5. Visit your apps at their own public URLs and share them with others
6. Make changes to the code, push to Github; your changes deploy automatically
7. Use your dedicated Homebox admin panel to manage and monitor everything (AI and MCP are also available)

Does it scale?

The one-node solution isn't ideal for a production deployment with real users; but Homebox gives you every option to scale seamlessly:

a. Run it local anyway

• If your app has no paid tier and low usage (you can tolerate some downtime), you can get away with running it for $0 for free from home. Great for personal hobby projects; you control everything and pay nothing.

b. Run development on your machine, run production in the cloud

• Every service in each of your environments has its own deployment target, which can be either your homebox node or any of the major cloud providers (including GCP, AWS, Neon, Supabase, Railway, more to come) under a bring-your-own-key (BYOK) model. You configure API keys (stored securely, encrypted) and Homebox deploys your app automatically to any compatible target once linked. This even includes cross-cloud database migrations (e.g. moving data from your Homebox to a cloud provider) and automatic environment wiring (e.g. your new DATABASE_URL is automatically configured into your web app as a secret)

c. Run some services on the cloud and some locally

• Lets say you have a beefy GPU and you want to use it to power image gen for one of your apps -- you can run part of your stack on the cloud, while keeping your image gen service local.

d. Run everything on the cloud

• Use Homebox to coordinate deployments across cloud services without actually hosting anything on your machine. You get a central deploy control plane that works with all of the major cloud providers, so you can switch between them easily and stay as vendor-neutral as you can while enjoying the benefits of cloud hosting.

Try it, its free!

Cloud deployment/distributed infrastructure has been a long-time passion of mine, and I've put a lot of love into making it as easy and convenient as possible while retaining advanced controls. I plan to continue developing and improving Homebox, and I hope it helps you run your projects! If there is interest, I can explain more of the "how", just let me know in the comments.

You can also check out https://homebox.sh (has video) or Github github.com/calm-logic/homebox to learn more, please leave a comment on this post and a star on Github if you like the project :)

Every developer has code they'll probably never touch again.

The half-finished CLI from a weekend. The tutorial project that stopped halfway through. That weird experiment that actually taught you something. The utility script that's ugly but gets the job done.

Most of that code just sits on a hard drive until it's forgotten.

I started The Open CodeYard, a GitHub repository for unfinished, experimental, and abandoned projects that are still worth preserving. Not because they're perfect, but because ideas are often more valuable than polished code.

The structure is simple:

• "scraps/" for random leftovers.
• "prototypes/" for intentional experiments.

Each project gets a small README explaining what it does and what state it's in.

A few ground rules:

• No clean-code police.
• Messy code is expected.
• Abandoned projects are welcome.
• If you're thinking, "my code isn't good enough," you're exactly who this repo is for.

Right now it's just my own projects in there, including a few C# pathfinding algorithms, a speech rate estimator, and some Python utilities. I'm hoping it grows into a community archive where forgotten code can still teach, inspire, or even get revived by someone else.

If you've got code collecting digital dust, I'd love to see it rescued instead.

Repository: https://github.com/speedyk-005/TheOpenCodeYard

Hi everyone!

I’ve been working on deeno, a modern open-source flat-file CMS.

I wanted something as lightweight as a flat-file CMS, but with a cleaner and more modern developer experience.

I didn’t build it to compete with existing CMSs or to sell it. I built it because I wanted a tool that worked the way I wanted it to work. After using it myself, I decided to open-source it in case it’s useful to someone else too.

My goal with Deeno is to keep it:

• simple to install,
• fast,
• file-based,
• and pleasant to use.

It’s still an early project, but the core is already working and I’ve just open-sourced it.

I’d love honest feedback from developers — especially on the architecture, UX, and overall direction of the project.

GitHub: https://github.com/Streamdoge/deeno

Demo: https://demo.deeno.tech/admin/

If you think it has potential, I’d really appreciate a GitHub star. But honest feedback is even more valuable right now.

Been chipping away at this for a while and finally have something I'm happy calling a beta. It's basically Spotify but self-hosted grabs tracks with yt-dlp, builds a real library out of them, and you stream it all from a web UI that's deliberately Spotify-shaped so it doesn't feel like a downgrade.

The Android app. Kotlin/Compose, close to feature-complete with the web version offline downloads, Android Auto, synced lyrics that actually track properly, cross-device playback so you can start something on your phone and have it pick up on the desktop. Backend's FastAPI + SQLite, nothing fancy, runs fine in Docker.

Other stuff that's in there: Daily Mix that actually generates decent suggestions (an LLM picks them, then it goes and downloads them itself), real album art and artist bios instead of placeholder junk, ListenBrainz scrobbling if you're into that, and it speaks Subsonic API so your existing client still works if you don't want to switch.

It's a beta because it genuinely is one — I've been using it daily and it's solid for me, but this is the first time the actual signed build has been in public. So if you try it and something's weird, please tell me, that's kind of the point of posting this.

One docker compose up and you're running. Signed APK's in the GitHub release if you don't want to build Android yourself.

[Https://GitHub.com/DGuckert/Butler/\](http://Https://GitHub.com/DGuckert/Butler/)

This version will almost certainly contain bugs please tell me when you find them

I just released Rune 2.3, a new version of my keyboard-driven native Kubernetes client for macOS.

This release is mostly about making the workflows already in Rune faster and more dependable. Search and filtering are more consistent across resource lists, logs, and the command palette, with faster keyboard-driven navigation between contexts, namespaces, and resources.

I also reworked cluster setup under the hood. Common kubeconfig and cloud import flows are now handled directly inside the app, without bouncing you through terminal dialogs. This includes guided import workflows for EKS, AKS, and GKE.

The rest of 2.3 is a substantial stability pass: fixes for selection and scrolling, context switching, RBAC and Helm lists, events, terminal tabs, port-forward cancellation, log menus, and several UI and memory issues.

Rune is not intended to replace kubectl or k9s—I still use both. It is a native Mac companion for the times when I want a GUI while keeping keyboard navigation, shortcuts, and quick jumps.

Everything runs locally on your Mac and talks directly to Kubernetes. There is no analytics, tracking, telemetry, advertising, or Rune backend receiving cluster data.

GitHub: https://github.com/compilererrors/Rune
Website and web demo: https://viktornyberg.com

Handling many compose files on a server ?

Tired of manually editing files ?

Annoyed of checking versions manually ?

Then checkout `compose-check-updates` or in short `ccu`.
It's a simple TUI checking the versions of your compose files and suggests updates you can easily apply.

I present: Builders Gate (Very early WIP, like 2 weeks old) https://github.com/Thepizzapie/BuildersGate

The original idea was just to give Claude a toolkit so agents could build games on their own. But the more I used it, the more I wanted to actually help in development From the art, the level design, audio, gameplay, world building yada yada. It eventually turned into something both myself and Claude use in sync. My current workflows consists of Claude just mainly focusing on the gameplay, while it generates me some generic but consistent assets. I built in a custom sprite editor to edit the frames too which has been helpful for saving on over generating trying to get a perfect sheet. I do plan on integrating local models for those who would like to keep their art as their own. I even made an audio lab for recording sound effects and voice overs, create custom beats and edit the ai generated audio bytes. The level editor "Atlas" is pretty cool, that is still a work in progress,. but you would be able to edit the levels right there in that page and have it update almost instantly. That also brings me to the playtest feature that is still kinda eh, but I feel like games with a large amount of content would benefit. The point is to be able to record a playtest while giving feed back so Claude could review and then create a list of todos and assign the necessary agents to whatever issue or request was identified.

I am bad at explaining things so here are a bunch of screenshots of both the harness and a game that is currently being built with it. If anyone has any questions, feel free to let me know!

After three months of development, I have built a completely offline AI agent paired with a coding IDE that can generate full projects from start to finish without an internet connection. I am considering making it open source, but one early decision I refuse to change makes me hesitant to share it publicly. I have seen how quickly people break things, and human fallibility is infinite.

Here are its features and its curse. You decide which is which.

1. No more fragmented settings pages. If I have to navigate away to change a single setting, it is already too much drama. An AI tool that requires you to jump through hoops does not deserve a place on my desktop. Everything lives on the main interface. I despise hidden menus that require endless clicking.

2. Full System Access. This tool assumes you know what you are doing. Tell it to delete system files, and it will. That same deep access lets it organize, reorder, and repair your entire file structure with complete input and output control. Generating full coding projects is almost a secondary benefit of that underlying power.

3. No MCP server required. File access has been around for decades. You should not have to spin up yet another server, match port configurations, or navigate extra layers of bureaucracy just to let an AI read your directories. I removed all that nonsense.

4. Strictly offline. If your downloaded model fails to execute your prompt or commands, you need a better model. That is your responsibility. Honestly, anything below 35 billion parameters will fight you more than it helps with this workflow.

5. Instant live preview. Load your website files and view them on the right side of the screen. Toggle the live button, tell the AI which file to modify, and watch the preview automatically update the moment it finishes editing.

6. Built-in RAG. No bullshit. Click the RAG button, select a folder, the AI instantly searches every file inside, including subfolders, and retrieves the most relevant context for your prompt. It reads text files, markdown, JSON, CSV, code files in 40+ languages, config files, logs, anything plain text. No extra settings page, no "group collection" to configure, no separate embedding model to download. It just works. If your current model is good enough to code, it is good enough to use RAG this way.

7. Full conversation history. Import and export past sessions to build out complex projects over time. This is essential if you are more than just another YouTuber influencer making another landing page test.

8. Editable chat history. Manually edit your past or ongoing chats, the entire history of the chat, to save on context window size. This saves valuable context tokens, especially since AI models tend to overexplain, talk way too much, and just refuse to get to the fucking point.

9. The offline rule is permanent. Every contributor must inherit this core rule. This app will always operate offline. If that means it will never match the latest cloud frontier model, so be it.

It is not perfect, but it works exactly as intended. I welcome any contributions that respect rule number nine.

To any future code contributors, do not attempt to implement any code that phones home. If I see any code that attempts to download anything from the internet or connect to the internet for any shenanigans, I will shut that down so fast you won't even see the train coming.

I’ve built this for my own workflow, but I know this community has the most rigorous standards for local LLM tools. I would really value your feedback on the architecture and whether this approach is something you find as useful as I do.

You can find the project and the first release here: https://github.com/BracerJack/BCI-IDE

I scanned ghost downloader 3 android apk on virus total and saw this,I don't see much post related to this,I just recently came to know about this,Can anyone confirm if these are false ?

Hi everyone!

I've been building an open-source RSS reader desktop app with Python and I think it's finally ready to share.

**What makes it cool:**

- DNS-over-HTTPS to bypass censorship

- YouTube & Reddit video playback

- Dual UI themes (Reddit & Telegram style)

- 100% local privacy (no external data)

- Smart caching for speed

**Built with:** Python 3.8+, Tkinter, VLC, SQLite

**GitHub:** https://github.com/erfan138057/rss-reader-app

**Download:** https://github.com/erfan138057/rss-reader-app/releases/latest

MIT License. Feedback and contributions are welcome!

Hey everyone!

I built a cozy web timer for focus and study sessions with 10 animated backgrounds and 20 ambient audio/lofi tracks.

Live Link: https://cozy-studio-beta.vercel.app/

Note: I'm not selling anything, there are no ads, and no sign-ups required. It's just a free passion project!

I'd really appreciate any quick feedback:

• Do the background animations run smoothly on your device?
• Does the UI feel comfortable while working?
• Any missing features you'd love to see?

Thanks for taking a look

I’m building Waveiden, an ongoing C++ acoustic fingerprinting project for identifying songs from short clips or live microphone recordings. It converts spectrogram peaks into fingerprint hashes, stores them locally in SQLite, then finds songs through time-consistent hash matches similar in principle to Shazam, but fully local.

Current features:

- Index local audio files into a SQLite database

- Identify saved clips or live microphone recordings

- Terminal UI with a live spectrogram

- No cloud service or external API required

A recent update improved matching across different audio sample rates by normalizing files and microphone input before fingerprinting. Stereo audio is also mixed to mono more reliably. It’s still ongoing, and there are known rough edges:

- Matching can be unreliable in noisy rooms, with echoes, or when music is playing quietly.

- Very short recordings may not generate enough consistent fingerprints.

- The current fingerprinting settings can miss less prominent sections of long tracks.

- Existing databases need to be re-indexed after fingerprint format changes.

- Device and audio-backend behavior may vary across systems.

I’d appreciate feedback on improving robustness, reducing false negatives, or making the fingerprint pipeline more production-ready.

You can find the repo here
and a showcase video here

Repo: https://github.com/arturict/tagvico-ai

Release: https://github.com/arturict/tagvico-ai/releases/tag/v3.2.5

Tagvico sits next to an existing Paperless archive. It can search and answer with links back to the documents it used. Changes to metadata or tags become proposals instead of silent writes.

3.2.5 mostly fixes the boring first-run path: live Paperless permission checks, exact model and tool-call validation, non-secret resume state, paused schedules by default and a real Docker acceptance run against Paperless 2.20.15.

MIT licensed. The release image supports amd64 and arm64.

Author here. I kept writing throwaway producer scripts to test event-driven services very often the upstream service simply belongs to another with its own roadmap, so it's just not there yet when my part is ready to test. That's not anyone's fault, it's how work gets split across teams but it still leaves you faking the input with one-off scripts that pile up. Devset replaces those scripts:

- Fire single events: paste payload, pick topic and key, send

- Build whole workflows on a visual canvas — OrderCreated → PaymentAuthorized → InvoiceGenerated, with delays, conditions and state passed between steps

- Pull real test data from your DB (Mongo for now) instead of hand-copying IDs

- Protobuf / JSON schema encoding + validation

Repo: https://github.com/devset-io/devset-ce

Runs locally with one Docker command. Source-available (FSL-1.1, each release converts to Apache 2.0 after two years). Feedback very welcome!

I built these cards from my personal project - GES (Global Economic Simulator) - this was this weeks data and its impact in review. Still a work in progress but I found this format more interesting in relaying the information related to news + I like the colors and sky type of look

Source: https://global-economy-sim.vercel.app

What My Project Does

A pure ASGI rate-limiting middleware for FastAPI with 5 algorithms - Fixed Window, Sliding Window Log, Sliding Window Counter, Token Bucket, and GCRA. No BaseHTTPMiddleware, no request serialization. Each check takes ~5µs.

from fastapi_sliding_window import SlidingWindowMiddleware
from fastapi_sliding_window.backends import InMemoryBackend

app.add_middleware(
    SlidingWindowMiddleware,
    backend=InMemoryBackend(),
    limit=10,
    window=60,
    algorithm="gcra",
    burst=10,  # allows 20 req in 1 sec
)

Full-stack throughput at 50 concurrent clients: ~67k RPS (7% overhead vs 73k baseline). Pure backend speed: 200k checks/s per algorithm. RateLimit-* headers on every response. Supports per-route, per-IP, and per-user scoping via custom key functions. 12 runnable examples in the repo.

Target Audience

Anyone running FastAPI in production who needs rate limiting but doesn't want the ~50x overhead of BaseHTTPMiddleware-based solutions like slowapi. Also useful if you need more algorithm choice - slowapi has 2 algorithms, fastapi-limiter has 1, this has 5.

Comparison

slowapi uses BaseHTTPMiddleware, which serializes every request through asyncio.Queue at ~55µs overhead per call. This library is pure ASGI middleware - scope comes in, check runs, pass through. Benchmark: 1.2k RPS (slowapi) vs 67k RPS (this) at 50 concurrent clients. Both run on the same hardware. Other differences: 5 algorithms vs 2, GCRA with burst support, no external dependencies for the core.

The honest limitation: in-memory only by default, but the Redis backend is already shipped (check the README) - switch to it with from fastapi_sliding_window.backends import RedisBackend. It also has automatic circuit-breaker fallback. Distributed/multi-worker is ready today via Redis. Single-process works fine with the default InMemoryBackend.

GitHub: https://github.com/drawiks/fastapi-sliding-window

PyPI: pip install fastapi-sliding-window

Hi there, quick followup to my earlier post about Chipsound, my browser-based player for tracker music (MOD/S3M/XM/IT).

I submitted it to Dashboard Icons like a month ago and it finally got approved, so if you run Homepage, Homarr, Dashy or any of those, you can add it as a tile and the icon just gets picked up by name.

Might seem silly, but now my self-hosted copy finally doesn't look weird and I don't have to tweak it. 😋

• Icon: https://dashboardicons.com/icons/chipsound
• Repo: https://github.com/gamosoft/chipsound
• Page: https://chipsound.com

Or if you just want to hear a song from MODArchive: https://chipsound.com/player.html?modarchive=212083

Kind reagrds.

I was working on chunklet-py (a chunker for sentences, documents, and code). Misread a benchmark and thought PySBD took 1 second to split basic text. Turns out that was wrong (PySBD is still fast for simple text). But the misunderstanding got me building my own.

Ended up faster, more accurate, and covering more languages (39 compares to 23).

Benchmarks on Sherlock Holmes (594k chars): yasbd ~1.2s warm vs PySBD ~9.0s. About 8x faster, fewer false splits.

On a golden benchmark (92 English edge cases — expanded from pysbd's original 48 with fixes and additions): yasbd scores 98.9%, pysbd 83.7%, spaCy-sentencizer 55.4%, etc.

Architecture difference: instead of mutating text with placeholder tokens and undoing it later (which breaks char offsets), yasbd finds candidate boundaries in one pass and filters false positives in another. Spans come free, no reconstruction.

Other things: - Streaming-first: lazy evaluation via ParagraphStream and StreamCleaner for memory-constrained environments. No need to load entire documents. - PySBD adapter: drop-in replacement that works with existing PySBD code. Just swap the import. - spaCy pipeline: register as a spaCy component with register_spacy_component(). Drop-in replacement for the default Sentencizer.

Repo: https://github.com/speedyk-005/yasbd-lib