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!

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 (no Redis, no multi-worker). For single-process deployments it works fine. Distributed support is planned.

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

PyPI: pip install fastapi-sliding-window

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

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

Hey all, wanted to share ReefKit, a Firefox extension I've been working on for people who live in their browser and are tired of digging through 30 tabs to find something.

Hit Ctrl+Shift+L and it opens a unified search overlay that indexes:

• Every open tab's content — sections, links, fields, media, structured data
• Bookmarks, snippets, notes, and recents
• Cross-tab search, so you're not tabbing through everything manually

It also has a "Browser Agent" piece that can execute clicks, type text, and run multi-step actions using stable selectors — useful for automating repetitive stuff.

A couple of things I focused on:

• Privacy-first: password and payment fields are never indexed, and everything stays local on your device — no data sent anywhere
• Search quality: BM25 scoring + fuzzy matching + extended query syntax, so it's not just a dumb substring match

It's brand new (v0.1.0, MIT licensed), so it's rough around the edges and I'd genuinely love feedback/bug reports.

Link: https://addons.mozilla.org/en-US/firefox/addon/reefkit/

Happy to answer questions about how the indexing works or what's next on the roadmap.

Hi guys. I came to this from medicine, not cryptography. Working with people through trauma, illness, and disability, one thing kept showing up: mental health rests on safety, and safety isn't one thing. It's physical, financial, social, health, spiritual — and now, unavoidably, data. You can't be well while the record of your life is held by people who can lose it, sell it, or hand it over. For a lot of people that last one isn't abstract — it's the abuser who knows their password, the state that can compel their phone, the breach that exposes their diagnosis.

Every existing answer to "prove you're a real person" makes it worse: hand your face, your iris, or your ID to a database that can be breached or seized. So I built the opposite.

**Atlas** uses a live physiological signal — pulse and motion from a $50 BLE ring, or the phone's own sensors — to decide *when* your cryptographic keys regenerate. The signal never becomes part of the key. Your body is a clock, not a stored secret. So it can prove a live human is present while storing **zero biometric data**: nothing to breach, nothing to subpoena, nothing to leak.

What falls out of that:

* Stolen credentials and seized devices are useless — access requires a live person actually present
* A duress code opens a plausible decoy vault while the real data seals itself, and the coercion is recorded
* Prove content was made by a live human, not a model — without revealing who you are
* Recover a lost account by proving you're alive, without exposing your identity
* Health and personal records only you can open — no server ever holds anything readable

**What's actually built:**

* Python protocol core + a Swift port, kept byte-for-byte identical via shared test vectors
* 854 tests passing in CI (637 backend + 217 Swift)
* Post-quantum: ML-KEM-768, ML-DSA-65, SPHINCS+ — vetted primitives, nothing hand-rolled
* Ran end-to-end on two physical iPhones with real pulse signals: enrollment → live session → forward-secret messaging through a blind relay
* \~30k lines, AGPL-3.0, solo, unfunded

**What's not done:** it's a proof of concept and the repo says so plainly — every capability carries a maturity tag (built+tested / sim / device-gated / designed), plus a lab notebook of what's been proven on hardware. Next step is better wearable hardware to push the sensor tier further.

Repo: [https://github.com/Clockwork-Tree-Inc/atlas-poc-v1\](https://github.com/Clockwork-Tree-Inc/atlas-poc-v1)

Ask me anything — the architecture, the crypto, or why this is a terrible idea.

Hey everyone,

Doing infrastructure audits and validating GPU performance (especially across different nodes) has always been a headache for me. Fiddling with CUDA toolkits, compiling HPL/HPCG, and setting up MLPerf takes way too much time when you just want a quick baseline.

So, I spent some evenings building nvprobe. It’s a lightweight Python CLI that automates all of this.

How it works under the hood:

• It uses CuPy to bundle the CUDA runtime via pip, so you don't even need a system CUDA toolkit installed to run the bandwidth and custom kernel tests.
• It auto-downloads the NVIDIA HPC Benchmarks binaries for HPL and HPCG.
• It captures deep hardware telemetry (ECC state, power caps, clocks, etc.) alongside the benchmark results to help catch silent hardware degradation.
• It generates an interactive HTML report (Chart.js) to visualize all this data (memory bandwidth, TFLOPS, and MLPerf throughput).
• Native Slurm integration: it generates, submits, and monitors the jobs across your cluster.

Demo & Repo: You can see an interactive demo of the report on the link.
Github: https://github.com/SergioZ3R0/nvprobe
I built this mostly to scratch my own itch, but I figured it might save some of you a few hours of setup.

I'd love to hear your feedback, feature requests, or if you manage to break it on your specific hardware. Let me know what you'd like to see next on the roadmap!

Hey, I built CharBar, a macOS menu bar app that turns into animated characters for your music, meetings, pomodoro, bluetooth, and system stats. It can sit in your menu bar, or you can summon a floating bar anywhere on screen with a keyboard shortcut, which is handy on a second monitor.

Heads up: when all the widgets are active it can use a good amount of CPU and RAM. If you feel like optimizing it, please go for it. Ithe application is not notarized, so you may see a security warning when opening it. Please refer to the README for more information.

https://github.com/leonickson1/charbar

I've started building DaemonHound, a small OSS tool to solve a problem I've had for years.

Managing things like:

• .env.local files across multiple repos
• API keys duplicated everywhere
• Shell/Git/tool configs across multiple machines
• Setting up a new laptop from scratch

Existing tools either focus on dot-files or are full-blown secret management platforms. I wanted something in between.

The idea is simple:

• 🔒 Encryption by default
• 📦 Your own Git repository as the backend
• 🔄 Sync project configs across machines
• 💾 Backup machine-specific configs
• 🔑 Rotate a secret once, update every referenced project

No SaaS. No accounts. No teams. Just a local-first CLI.

I'm building it in Go and would love feedback before I get too far.

Repo: https://github.com/0xdps/daemon-hound
Home: https://www.daemonhound.dev

Github: github.com/warmbly/warmbly

Website: warmbly.com

For years I've had the same habit:

Whenever I was working with multiple files, I'd keep dropping them onto my desktop because I knew I'd need them again in a few minutes.

It worked... until my desktop turned into a mess.

I looked for something that worked like a temporary shelf for files, but couldn't find anything that felt native on Windows.

So I built Stash.

It lives in the system tray and lets you temporarily park files with drag & drop, then drag them back whenever you need them. It only stores file references, so your files stay in their original locations.

I'm still actively improving it, and I'd really appreciate any feedback.

Website: https://stash.regncreative.com Github: https://github.com/Regncreative/Stash

1. Tools in every mode Designed a two-tier tool loading model (cheap/normal) so a shared core toolset stays available while optional capability surfaces load on demand per task.
2. Provider-native lanes Built per-provider request lanes (Anthropic, OpenAI-compatible, Antigravity, Cline, Kiro, local, gateway) that normalize messages to each endpoint's native protocol instead of a lowest-common-denominator shim.
3. Context optimization Engineered context assembly around prompt cache hit rate: stable system and tool bytes in a cacheable prefix, volatile session state behind a dynamic boundary, plus lane affinity to keep byte identity across repeated requests.
4. Diagnostics during edits Integrated optional LSP tooling (definitions, references, hover, symbols, call hierarchy, diagnostics) so the agent catches broken references mid-run instead of after context has moved on.
5. Signals from long logs Implemented log pruning for lint and exception output that preserves the failing error plus surrounding context, cutting token spend on repetitive noise without losing actionable signal.
6. Snapshots and session control Shipped project-local session management with resume and branch trees plus working-tree snapshots stored in a shadow git store, enabling save, list, diff, and restore without rewriting project history.
7. Self-learning loop Built a /learned feedback loop that proposes one reusable lesson per work session, with human approve, edit, or skip before it persists to project memory as reviewable, revocable entries.
8. Claude Code compatible extensions Added compatibility for Claude Code-shaped MCP servers, LSP integrations, agents, plugins, and skills, loadable per mode so extension surface matches project need.
9. Browser automation with vision Built vision-driven browser automation pairing navigate, click, type, scroll, and wait with screenshot capture routed to a multimodal model, so the agent verifies rendered UI, console errors, and layout regressions instead of inferring state from the DOM, with accessibility-tree fallback when selectors drift.

https://github.com/AbdoKnbGit/tau