Ever since I was a kid, I was fascinated by spy movies, hacker movies, and the huge intelligence maps you always saw on screen.

As I got older, I realized there are real platforms that solve similar problems, but they're generally proprietary and out of reach for most developers.

I kept wondering what an open-source version could look like.

So over the past few weeks I've been building Akashic.

Akashic is a self-hosted intelligence workspace that brings together aircraft, satellites, earthquakes, weather, public radio, infrastructure, country intelligence, public cameras, and other OSINT sources onto a single interactive map.

The goal isn't to replace every existing service.

It's to make exploration easier.

Instead of switching between multiple websites, you can combine layers, inspect entities directly on the map, and correlate information from different public sources in one workspace.

Current highlights:

• Open source (MIT)

• Self-hosted

• No mandatory API keys

• Built in public

This is still an early project, so I'd genuinely appreciate feedback on the direction, missing features, or things you'd like to see.

GitHub:

https://github.com/caviraoss/akashic

Demo:

https://www.youtube.com/watch?v=qsWHhuIwR8c

Hi all,

As i'm working on growing launchpact.io i'm seeing a lot of unprepped launches and as the day unfold they don't get much visibility and end up with a failed launch.

This is one of the reasons i build launchpact.io, if you have an upcoming launch do check it out and prep ahead of time, i also added this checklist that can give some hints too, have a read.

Good luck everyone!

I built HeyZoku.
PH - https://www.producthunt.com/products/heyzoku/launches/heyzoku-hands-free-coding

As the models are getting much better at understanding us directly via voice, we should be working towards finding more ways to improve our productivity and do better work. And shouldn't be limited to just chat/keyboards to do our work. With how humans naturally communicate with each other, it should be the same way with the machines, a human shouldn't need to learn how a computer works - it should be natural.

So today I am launching HeyZoku - Hands Free Coding. So you can control all your coding agents just with your voice and complete your work without any need to continuously touch your keyboard.
I am using Nvidia Parakeet to make it work completely offline - so it can work completely offline. (It also has an optional bring your own openai-realtime key for more natural and multi language support.)

Open to any kind of questions or feedback and thank you for your support.
An upvote would mean a lot!

our friend group is split across spotify, apple music, youtube music and even vlc. theres no way to see what everyone is playing unless you're all on the same app.

so we started building vynu, an android home screen widget that shows what your close friends are currently listening to in a compass style view. designed to work across different music players.

its not a streaming app or a social network. just a small quiet widget for close friend groups who want to know what each other are playing.

we're still early and want to see if this actually resonates before we go all in. if you’d use something like this, join the waitlist at getvynu.com so we can measure demand.

would love honest feedback, would you actually keep this on your home screen?

After about 2 months now since I launched https://certleaf.com today was the first purchase!

What has worked really well for me is a consistent workflow for publishing blog posts everyday and social posts everyday. All my posts and articles are generated by AI to follow a certain theme and match keywords and delivered for approval on telegram. I approve the ones that are good or suggest changes. This has meant a consistent growth on SEO without having spent a penny on backlinks yet.

I've been building Pinaka on the side for the past few months — an AI agent that automatically writes root cause analyses when a bug ticket is filed.

The problem it solves: every time a production bug hits, a senior engineer spends 2-3 hours investigating before writing a single line of fix. The actual fix takes 20 minutes. The investigation takes the rest of the day.

Pinaka eliminates that investigation step. Tag a Jira ticket or mention @pinaka-app on a GitHub Issue — it reads your indexed codebase, captures runtime context via an SDK, and posts a structured RCA as a comment. Root cause, exact file, exact line, fix approach. Automatically.

What I've validated so far

Ran it against real open source bugs:

• BullMQ issue #2487 — code only scored 6.5/10, code + runtime context scored 9.2/10 against the actual merged fix
• Prisma ORM issue #29480 — open bug, no ground truth, diagnosed from behavioral contrast across test files
• Pinaka's own Java SDK — found a real ForkJoinPool exhaustion bug, fix shipped same day

All three write-ups are public, including the limitations.

What I'm looking for

couple of engineering teams (2-150 engineers) using GitHub who want to try this on a real production bug. Free, no commitment. I'll personally onboard you and be available for any questions.

Works with Jira and GitHub Issues. No Jira required. One OAuth click to connect. First 5 RCAs free.

Honest state of the product

No paying customers yet. Building in public. The product works — the benchmarks above are real — but I need real teams on real codebases to validate it beyond my own test cases.

If this sounds useful for your team, drop a comment or DM me. Happy to show you a live demo on your repo.

👉 getpinaka.com

I’m hiring a GenAI + Frontend Intern at Empulse Labs.

We build custom software and AI systems for SMBs, and you’ll work directly on real client/product work rather than just internal experiments.

What you’ll work on:

• Building quick websites and web apps
• Working with GenAI APIs and AI-powered features
• Building and iterating on frontend interfaces
• Prototyping ideas quickly and turning them into working products
• Using AI coding tools as part of the development workflow

What I’m looking for:

• Beginner to intermediate developer
• Students are welcome, personal projects count
• You don't need to have everything figured out
• Experience with Claude, Cursor, and Figma is a plus
• Strong willingness to learn and build

Details:

• Full-time
• Remote
• 9 AM – 5 PM IST
• Paid internship
• Potential for a full-time role after the internship

If you're interested, please fill out this form: https://formhug.ai/f/Irj0SI

Most "AI reviews your PR" tools annoy me. They hallucinate nits, the output changes every run, and you can't tell if a flag means anything. So I wanted to know if you can get a useful review signal the boring way. Static metrics plus git history, without any LLM in the loop, so same input gives the same output every time.

The question I actually wanted answered: do deterministic code-health metrics predict which files get bug-fixed later?

How I set it up :

• Score every file at a historical commit (T0).
• Count bug-fixing commits to that file over the next 6 months.
• Correlate the T0 score with the bug-fixes that came after. No file sees its own future.

Metrics are the usual suspects plus churn signals. McCabe complexity, deep nesting, LCOM4 cohesion, god classes, clone detection, function-level churn, code age, ownership spread, change entropy. 25 of them, combined into a 1-10 per file. I ran it across 21 OSS repos, 9 languages.

What came out:

• Mean ROC AUC 0.74 at picking the files that go on to get bug-fixes. Up to 0.90 on some repos, weaker on others.
• It survives controlling for file size (partial Spearman -0.16). So it's not just "big files have more bugs," which was my first worry.
• Out-ranks churn alone by about +0.10 AUC, and prior-defect history by +0.12.
• Held on an external dataset I never touched (PROMISE/jEdit), AUC ~0.77.

I ran it head to head against CodeScene too, same 2,770 files, same commit, same labels, since it's the closest established tool. Discrimination was close (0.73 vs 0.71). The gap showed up on effort-aware ranking. Under a "you only have time to review 20% of the changed lines" budget, the deterministic score surfaced more of the real defects (recall 0.17 vs 0.07, Popt 0.61 vs 0.46). Similar at telling risky from safe, better at ordering what to look at first.

Where it falls down, because 0.74 is not magic:

• It tells you where bugs cluster, not what the bug is.
• Ranks files, doesn't read them so not a review replacement.
• Defect labels come from bug-fix commits, which is a noisy heuristic. Some "fixes" aren't, some bugs never got a clean fix commit. That ceiling is baked in.
• The 6-month window is a choice. Move it and the numbers move.
• The CodeScene edge is specifically ranking under a budget. On raw "is this file risky, yes or no," they're close.

Where I landed: the signal is real and it's reproducible, which is the part I care about for PR gating but it won't catch a logic bug in a 4-line diff.

It's good at "this PR touches a file that's been a problem for a year with one owner, slow down." Different job than line-by-line review, and I think it's the job the deterministic approach is actually good at.

I have also added agent provenance to the same which allows it to determine if an AI PR is worse than human

If anyone wants to take a look at the repo: https://github.com/repowise-dev/repowise

Also, if you have any feedback on the metrics itself or if I can try some new metric, would love to try that

Disclaimer: I am the author of this tool. It runs locally, is completely free, and is licensed under Apache 2.0.

Hey everyone,

3 years ago, I heavily leveraged Claude and Cursor to "vibe code" an early prototype. It got us from 0 to 1 rapidly, got paid users, but it left behind a massive architectural bottleneck: a ballooning codebase of 500 scattered files filled with disjointed logic.

When edge cases broke production, dumping 500 line functions back into Cursor failed. Existing tools only lint or summarize single files. they don't map business workflows

Out of my own necessity, I spent the last 3 months building open source local python package UnvibeCode

how to use unvibecode:

pip install unvibecode
python -m unvibecode review --repository "/path/to/repository"

4 Practical Outputs it Gives You:

1. Interactive Connected Code Map: A local, interactive graph showing connected codes across different files so that you can understand the code
2. LLM-Ready Context JSON: Automatically packages the connected, relevant code chunks for debugging so you can give LLM the right context
3. Business Workflow Reconstruction: Reconstructs workflows hidden in complex (e.g., tracking a payment across routes).
4. Business Risk Findings: Scans the workflows to flag structural business risks like duplicate payment loops, authorization edge cases, or broken failure paths.

I am looking for blunt technical feedback from the community:

1. If you run pip install unvibecode on an unfamiliar or complex codebase, does the interactive graph layout generate a readable system architecture?
2. Am I approaching this the right way, or is trying to map 1,000s of business workflow scenarios from AI slop a losing battle?

Repo: https://github.com/FinanceFlash/unvibecode

PS: (GIF of the tool in action posted in the comments below!) Please tear the logic and schema design apart, share your thoughts to help me fix things in the repo

I've spent the last few months building something and I'm finally at the point where I want to share it properly rather than just quietly hoping people find it.

The idea came from a frustration I kept seeing (and feeling myself): SQL tutorials teach the syntax fine but there's never a reason to care about the answer. You filter a table called employees, get a result, and nothing happens. Your brain doesn't bother keeping it.

I wanted to try a different approach. QueryCase teaches SQL through detective investigations. You get a briefing from Chief Fox (our mascot), a real database to query, and a mystery to crack. The JOIN matters when a suspect has an alibi. The WHERE clause matters when you're trying to find who entered the building at 22:13. The SQL is the tool for solving something, not the point in itself.

Here's what's actually in it:

• A structured learning path across 54 cases, going from Recruit through Rookie, Detective, Senior Detective, and Chief Detective. Each rank has drills and a level exam to pass before you progress.
• Sandbox mode where you can explore real datasets (IMDB movies, Spotify, sports stats, Steam games) and run whatever you want with no pressure and no mystery attached. Just free exploration against actual data.
• Everything runs in the browser using DuckDB WASM so there's nothing to install.

I'm a solo developer and this is genuinely early days. I'm sharing here because this community is exactly the kind of people I built it for, and I'd rather get honest feedback now than find out later I've built the wrong thing.

What's missing? What would make you actually stick with something like this versus what you've used before?

querycase.com if you want to take a look.

Any feedback appreciated!

Hey everyone,

Cloud-based productivity apps have normalized scanning our private notes and locking access behind recurring paywalls.

To solve this for myself and the privacy community,

I built **Pariyojana** — an open-source, local-first Android workspace engineered with a zero-trust threat model.

### 🛡️ Security & Privacy Architecture:

1. **Zero Cloud Sync:** No accounts, no background tracking, no servers. All data lives strictly in a local SQLite database encrypted with **256-bit SQLCipher AES-CBC (64,000 PBKDF2 iterations)**.

2. **Android KeyStore TEE Hardware Sealed:** The master key is derived inside your device's hardware enclave.

3. **Anti-Forensics RAM Zeroing:** Decrypted API keys and sensitive tokens are actively overwritten with zeroes (`0x00`) in volatile RAM on app background/lock to defeat memory dumps.

4. **DRM FLAG_SECURE:** Blocks screenshot capture and OS task switcher previews.

5. **BYOK (Bring Your Own Key) Direct AI:** AI queries (via OpenRouter/DeepSeek/OpenAI) route directly from your phone to the endpoint via HTTPS. Zero intermediary logging proxy.

It combines an Idea Vault, a 6-stage Kanban board, an academic paper research hub, and a job tracker into one unified offline app.

* **License:** MIT

* **Cost:** 100% Free ($0 Lifetime)

📦 **Source Code & Audit:**

https://github.com/Naveen-21-Cyber/Pariyojana-Mobile-App-

⬇️ **Direct APK Download:**

https://github.com/Naveen-21-Cyber/Pariyojana-Mobile-App-/raw/main/Pariyojana.apk

🌐 **Website:** http://pariyojana.gt.tc/

Feedback and security audits are welcome!

I'm researching a problem around lost team context, decisions, project history, unfinished work, etc. that effectively disappear when someone leaves or is unavailable.

Curious how other teams handle this today. I put together a short anonymous survey (~3 min) to collect some data:

https://forms.gle/TKBoD4guTRy2XvZ96

I'm trying to validate the problem before building a solution. Honest/negative answers are especially useful.

If you've ever tried to figure out what is eating up your Android's storage before doing a massive data dump, you know the pain. Trying to view a /DCIM folder with 10,000+ files over a standard USB cable usually makes Windows Explorer or macOS Finder infinitely load, freeze, or crash because MTP is fundamentally broken for high file counts.

I got tired of waiting 4+ minutes just to see my folder sizes, so I built an open-source analyzer called SocketSweep that bypasses MTP entirely.

How it works (The Architecture): Instead of using standard USB bulk transfers to read the filesystem, it uses a multi-language stack to pull the file tree at bare-metal speeds:

• The Engine: It pushes a native C++17 daemon to /data/local/tmp via ADB. Because it runs under the shell context, it executes POSIX filesystem traversals natively on the device. (Zero root required).
• The Bridge: It pipes the raw JSON tree data back to your PC over a local TCP socket tunnel, bridged via adb forward.
• The UI: A Rust/Tauri desktop app consumes the TCP stream concurrently and maps your entire storage into an interactive React Treemap.

The result: You can visually hunt down your biggest folders and delete the junk instantly. A 4-minute MTP "Loading..." hang becomes a 1.2-second instant scan.

Right now, the first release is compiled for macOS (Windows/Linux builds via GitHub actions are next, but you can build from source). It is GPL-3.0.

• GitHub Repository: https://github.com/VishnuSrivatsava/SocketSweep
• Download macOS .dmg: https://github.com/VishnuSrivatsava/SocketSweep/releases/tag/v1.0.0

(Note: For Android 11+, the app automatically uses an appops ADB command to grant itself Scoped Storage bypass permissions so it can read your full /sdcard without issues).

Let me know what you guys think of the architecture!