I’ve been working on Tabularis, an open-source desktop database client for Postgres, MySQL and SQLite.

It’s meant to be two things at once: a comfortable everyday SQL app (editor, notebooks, charts, visual tools) and a safe bridge for AI agents that want to read your schema or run queries, without you having to paste credentials into a chat.

Free, open source, runs locally. Would love your thoughts.

→ https://github.com/TabularisDB/tabularis

→ https://tabularis.dev

It's called OSIRIS.

You open a 3D globe in your browser and see, in real time:

→ +10,000 planes in the air
→ +2,000 satellites
→ CCTV cameras from around the world
→ fires, earthquakes, maritime traffic
→ 13 active conflict zones

all on a single screen.

and it doesn't stop there.

it comes with an OSINT toolkit inside:
port scanner, DNS, WHOIS, domain analysis.

This is:

→ open source
→ MIT
→ docker compose up
→ ready

most sources work without entering even a single API key.

why it matters to you:

the kind of intelligence that governments used to have exclusively...

now you can set it up on your laptop in 5 minutes.

ideal for journalism, security, or verification.

Live Site : https://osirisai.live/

Github : https://github.com/simplifaisoul/osiris

https://github.com/Alexandro521/Tanko/releases/tag/v2.1.0

without AI

https://github.com/omricn/stfu

Side project that started as "I need my kid to stop screaming at midnight while he games with headphones on" and turned into a properly engineered tool with 437 tests and a three-mode detection system.

Monitors mic input, calibrates to the user's actual voice (quiet/speaking/yelling), triggers escalating consequences when yelling is detected. First strike: minimize + sound + overlay with a jumping close button (4 clicks). After that: Win+D + fullscreen message.

PIN-locked settings, JSONL event log, report UI with charts, three threshold modes (wizard/manual/adaptive), headless CLI, 437 tests. Decision logic is pure Python with no audio/UI imports (AST-enforced).

No audio recorded. No network code.

flow just hit 0.2.0, and it's the biggest update since launch. A quick recap for anyone new here: flow is a real time terminal bandwidth monitor with Braille grid waveforms, spring smoothed numbers, and glowing borders that react to traffic load.

What's new

Throughput values now actually use the spring physics the README always claimed. Numbers glide toward their targets instead of snapping, which sounds small but changes how the whole dashboard feels under load.

The ping target is now configurable. It defaulted to 1.1.1.1 and had no way to change it. Now you can set ping_target in the config or pass --ping on the command line if you want to check latency against your own gateway or a different host entirely.

There's a new streaming JSON mode. --json-stream writes one JSON object per line to stdout, continuously, so you can pipe flow into whatever else you're building. This was the most requested feature since --json and --once shipped.

Daily totals now survive restarts. They get written to ~/.config/flow/stats.json on quit and reloaded on the next launch, so closing your terminal doesn't wipe out the day's numbers anymore.

Themes are no longer limited to the 8 built in ones. Drop a .toml file into ~/.config/flow/themes/ and flow picks it up automatically at startup. Full control over colors and gradients if the defaults don't match your setup.

There's also a public roadmap now (ROADMAP.md) laying out where 0.2.x through 0.5.x are headed, and test coverage got a real pass, especially around the spring animation math and the history persistence round trip.

Since the last big writeup

If you've been following along, a lot happened between 0.1.1 and 0.1.7 too: a theme selector, bits/sec toggle, live ping indicator, a network processes panel, an interface details overlay, reset confirmation to stop accidental data loss, and a full typography and spacing pass that gave the whole UI a much more deliberate hierarchy. 0.2.0 is really the point where all of that groundwork turns into new capability instead of polish.

Usage

flow                        # hero view, auto interface
flow --compact               # numbers only
flow --tiny                  # tmux status bar
flow --json-stream            # continuous JSON Lines, new in 0.2.0
flow --ping 8.8.8.8            # custom ping target, new in 0.2.0

Install / upgrade

go install github.com/programmersd21/flow/cmd/flow@latest

Pre-built binaries for Linux, macOS, and Windows are on the releases page. Config and theme files are backward compatible, nothing to migrate.

Links

Source, changelog, and roadmap: https://github.com/programmersd21/flow

Appreciate everyone who's been using flow and sending feedback, it's shaped most of what shipped in this release. If it felt cool, a star on the repo goes a long way.

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

I’ve been working on InstaAddict, basically a maintained fork of GramAddict.

GramAddict was a pretty cool open source Instagram bot that used ADB + uiautomator2 to control the actual Instagram app instead of relying on private APIs. Unfortunately, it hasn’t really been maintained, and Instagram’s UI has changed quite a bit since then.

I started fixing things as I came across them. Some of the stuff I’ve fixed so far includes media types being detected incorrectly, clicking a user from the likers list opening the wrong profile, retry loops getting stuck for ages on certain post types, and compatibility issues with newer versions of uiautomator2.

It’s completely free and open source. There are no subscriptions or locked features.

No root needed either. You can run it on a physical Android device or an emulator.

You can configure delays, interaction limits and filters for the types of users you want to interact with.

I’m also keeping track of the fixes in the changelog so it’s easier to see what’s actually being worked on.

If you want to try it:

pip install instaaddict

Or grab the source here:

https://github.com/joeahkim/InstaAddict

I’m still actively working on it, so if anyone runs into something that’s broken or has questions, feel free to ask.

Letting an AI agent loose on my real files always made me nervous: it runs a dozen tool calls, edits files, runs shell commands, and if one is wrong there's no clean way back. Git only covers tracked files, not the untracked mess or the shell side effects. So I built opendot around fixing that.

The core idea is reversibility. Before every file write or shell command, opendot snapshots the working directory into a content-addressed store (each file stored once, so it's cheap) and logs it to an append-only ledger. Then opendot undo walks it back exactly, opendot redo re-applies if you went too far, and opendot diff <id> shows which files an undo would change before you commit. Files and shell commands, not just in-repo edits.

The part I care most about is being honest about what can't be undone. A classifier separates workspace-contained commands (auto-run, undoable) from escaping ones (network, sudo, git push, deleting outside the workspace), which get flagged and confirmed first with a plain note that they aren't reversible. When it's unsure, it asks.

One thing I learned: "just undo" isn't enough to actually trust an agent, you need to see the state. So opendot log shows a timeline with a "you are here" cursor, so you can tell at a glance what's applied and what you've undone but could still redo.

The rest: model-agnostic via LiteLLM (OpenAI, Anthropic, Google, DeepSeek, local Ollama), budget caps (--usd 0.50 stops the run at 50 cents), a permission policy (--yes plus --allow/--deny) for unattended/CI runs, MCP client + Composio for 1000+ app tools, and session resume.

MIT, and I actively review PRs (good-first-issues if anyone wants to jump in).

pip install opendot

Repo: https://github.com/vedaant00/opendot

Happy to answer anything about the reversibility approach.

Jentic One is a free, open source, self-hosted execution layer that sits between your agent and the APIs you want it to reach. Apache-2.0, runs on your own box or your own infra.

We started working on this project so we could give our agents more autonomy. With current setups, that is very risky - if an agent goes rogue, the damage is often unbounded. We’ve all heard the stories of agents deleting entire inboxes or codebases. If we narrow the blast radius, we significantly reduce the risk. 

The top three pains when your agent touches real tools: 

- The keys are everywhere. Most of them are in env files, so there’s no clean way to revoke access if something goes wrong. 

- Once an agent has a key, it can do anything that key can do. The workaround could be writing soft permissions in a file (a 'request', not an enforced rule) or creating an API spec with just that one endpoint, so the agent can't get to anything else even if it wanted to.

- No way to see what your agent has actually done. So if the worst happens, it’s even harder to figure out the blast radius and where things went wrong. 

Here’s what we built to fix them:

- Credential handling. Credentials are stored once, encrypted, by your own instance, and injected at execution time. They never enter the agent's prompt, logs, or context. One server, many agents, each with its own identity, rather than one shared master key every agent inherits.

- Permission scoping. You write rules that bound an agent to the operations it needs and nothing else. On GitHub, that can be down to a single repo. How granular it gets depends on the API, and writes are denied by default. Anything you haven't allowed is refused before it reaches the API. The agent cannot do it. 

- Audit. Every call is logged on your own instance, append-only, so you can go back and see exactly what your agent did when you were not watching.

Ways we’ve tried to make this a great product (not just cover the risks): 

- One connection path. Install once, add any API from the Jentic API Directory (more on this below) or upload your own API spec, and store each credential once. No hardcoded integration per API, no region-picking, no retry plumbing by hand.

- Discovery by intent. Agents find what they need by asking in natural language, like ‘send a webhook’ or ‘create an invoice’, and get back the right operation with its input schema.

- A directory of agent-ready APIs. This is probably a different post in itself, but we’ve been compiling thousands of public API specs and curating them, making them agent-friendly (writing OpenAPI specs where none exist), and scoring each one for agent readiness. These are all available in the product, so you can get started with thousands of APIs out of the box. 

** Jentic One repo: https://github.com/jentic/jentic-one **
We’ve written AGENTS md so that you can hand it to your agent and let it do the bulk of the setup work (not all). Interested to see how that goes for people!

It's a public beta. There may be breaking changes with new releases.
Before you put real credentials in, read the hardening guide: https://github.com/jentic/jentic-one/blob/main/docs/security/hardening.md
Essentially, your agent and your keys shouldn't live in the same container.

Two things that would help a lot.
-Install it and let us know what breaks.
-If an API you need isn't in the directory, add it to the repo - then it's there for everyone else's agent: https://github.com/jentic/jentic-public-apis 

We would really appreciate feedback, issues, and contributions. 

I have been building this on and off for a while and it is finally at the point where handing it to someone else is not embarrassing, so here it is.

Citadel is a desktop infinite canvas. You drag in images, GIFs, video, audio, 3D models and PDFs, write notes and text blocks beside them, and draw labelled connections between things. It is for work where the layout is the thinking: visual development, research, worldbuilding, study.

The reason I started it: I used PureRef for years for images and kept everything else somewhere else. Notes in one app, clips in another, code snippets in a third. I wanted one board that could hold all of it and still be searchable a month later.

Three things ended up mattering more than I expected:

Connections carry meaning. A thread between two items can be a source, a contradiction, a question, a proof, an echo of something elsewhere. The Index searches every board at once, including code card contents and connection labels. That is the part that makes it hold up past about fifty items.

Vision checks. Y redraws the whole board in greyscale, blurred for a squint test, or through three colourblindness simulations. Shift+M mirrors it, which is the old trick for catching drawing errors your eye has stopped seeing.

Undo and recording are the same event log, so you can scrub the board back through its own history and watch it assemble itself.

It is local-first in the boring literal sense. No account, no telemetry, no update check, no network request on launch at all. Fonts are bundled. Projects are JSON with relative asset paths, so nothing is trapped in a database you cannot read. MIT licensed.

Honest limits: Windows and Linux only (macOS runs from source but I cannot notarise it), builds are unsigned so SmartScreen will warn on first run, PDFs get a first-page preview rather than a real reader, and document import gives you the plain text, not the formatting.

Repo: https://github.com/kannibalk1w1/Citadel. Downloads and a version that runs in the browser: https://kannibalkwi.itch.io/citadel

Happy to answer anything. What I would most like to hear is where it falls over on large boards, because that is the part I cannot test properly on my own.

Hey r/pihole,

I've been running Pi-hole for a while and got tired of opening the web UI every time I just wanted to check status or unblock something for five minutes. So I built Holeberry, a native macOS menu bar app for it. Free and open source (MIT).

What it does:

• Lives in your menu bar, shows status and total queries/blocked at a glance
• Manage up to two Pi-hole instances at once. Every action (block/unblock/allowlist) applies to both, so they never drift out of sync
• Disable blocking globally with a timer (or indefinitely). An auxiliary countdown will be right in the menu bar; re-enables automatically
• One-click unblock of whatever site broke in your current browser tab (Safari, Chrome/Chromium, Firefox/Zen), without a global disable
  • (My favorite feature)
• Browse recently blocked domains and allowlist/unblock them straight from the menu

Why Holeberry and not another app?
I looked around before building this. Some of the existing companion apps for Pi-hole weren't in active development anymore; felt outdated or didn't do the things I actually needed day to day: keep two instances in sync, and unblock just the tab I'm on instead of disabling blocking for the whole network. Those ended up being the two features I use most, so they became the core of the app.

Requires macOS 14+, supports Pi-hole v6 (and v5, though less tested). Credentials live in Keychain, nothing written to disk.

Also worth being upfront about: most of the code was written with AI assistance. I directed and reviewed every architecture decision, feature, and design choice myself, but the AI did a lot of the typing.

GitHub: https://github.com/pedrovieira/Holeberry

Happy to answer questions, and open to feature requests / bug reports.

Hey everyone! Wanted to share something I've been working on lately. As an indie developer, I was wasting so much time on repetitive manual tasks, so this weekend I finally sat down and coded two lightweight tools to make my life easier:

• LostMediaGrabber: Built to bypass the painfully slow Wayback Machine interface. It queries the CDX API directly to grab raw media URLs (.jpg, .mp4, etc.) instantly.
• GiveMeText: Made this because I got sick of having to pause YouTube videos or Google Meet calls just to take quick notes. It extracts live transcripts straight into formatted documents.

Both are 100% free and open-source. I built these mostly because they solved a real headache for me, and I figured they might come in handy for someone else too.

If anyone's curious to see how they work or wants to check out the code, you can find the direct link on my profile! I'd love to hear your thoughts or any feedback you might have.

Hey Folks I made the following website full of small tools to use free of charge, no ads , no signups and all source code is available on github.

plus, it created without usign any dependency or ...

Let me know what do you think?

https://jsglobe.com/

https://github.com/samalstudios/jsglobe

PageLM — Open-source AI education platform that turns PDFs into quizzes, flashcards, notes, podcasts and exams

GitHub: https://github.com/CaviraOSS/PageLM

I built PageLM, an open-source AI education platform for turning study material into interactive learning experiences.

Instead of:

PDF → Chatbot

PageLM aims for:

PDF → Chat → Notes → Flashcards → Quiz → Podcast → Exam → Review

Features

📖 Document Chat
Ask questions about PDF, DOCX, Markdown and TXT files.

📝 SmartNotes
Automatically create structured/Cornell-style notes.

🧠 Flashcards
Generate study flashcards from your material.

❓ Quizzes
Interactive quizzes with hints, explanations and scoring.

🎙️ AI Podcasts
Turn learning material into audio.

🎤 Voice Transcription
Turn lectures and voice notes into searchable study material.

📅 Homework Planner
Use AI to organize assignments.

🎓 ExamLab
Simulate exams and get feedback.

⚔️ AI Debate
Practice reasoning and debate skills.

🤖 Study Companion
Personalized AI study assistance.

AI providers

OpenAI
Gemini
Claude
Grok
MiniMax
OpenRouter
Ollama

Stack

Node.js + TypeScript
React + Vite + TailwindCSS
LangChain + LangGraph
WebSockets
JSON/vector DB support
Docker/Docker Compose

The project is open source and we're actively looking for contributors.

If you're into AI, RAG, education, React, TypeScript or just cool GitHub projects, I'd love to hear what you think.

⭐ Repo: https://github.com/CaviraOSS/PageLM

Issues, feature requests, PRs and criticism are welcome.

"AI writes your contract" terrifies me for v4 hooks specifically. a hook runs on every swap, so a subtly wrong one can trap or drain a pool. codegen isn't the scary part, unsafe deploy is.

came across aeon's deploy-uni-hook skill and the interesting bit is the pipeline around the generation, not the generation itself. you give it a brief (or pick a pre-audited template like dynamic-fee), it generates the hook plus a test pool, then it gates the deploy: static audit, dangerous-pattern scan, a behavioral forge test, and a fork simulation. dry-run on testnet by default, mainnet needs an explicit arm flag and a second opt-in. the broadcast is the last thing that happens, only if the sim passes.

first agent contract flow i've seen that treats "don't ship garbage to a live pool" as the actual hard problem instead of the codegen.

it's open source, the skill file and hook template are readable here: github.com/aeonfun/aeon (skills/deploy-uni-hook).

buenas buenasss, migente quiero mostrar aqui (nuevamente) mi nuevo repo/proyecto!!!!

Que es? es una herramienta que clona TODO, lo de un perfil de github a otro en segundos, cuando te digo todo te digo codigo, informacion del perfil, TODOS los commits, TODO lo posible basicamente. pasas de tener un perfil recien creado sin nada a un perfil identico a otro con todos sus commits, repos, informacion etc...

¿Que problema soluciona? imaginate que pierdes tu cuenta :(, puedes recuperarla completamente con Github-Profile-Cloner, o simplemente copiarle la cuenta a cualquier persona XD,

Cuenta con version en consola y version en web para los que le tienen miedo a la consola

en la carpeta examples/ hay imagenes de como se ve y tambien pueden ver los resultados en el perfil de github "jeffmarlonmandela" que fue el que use de ejemplo y es la copia de mi perfil

No me hago responsable de plagios, suplantaciones o cualquier cosa ilegal (no esta pensada para ello, o si), bueno espero os guste

https://github.com/ropydev/Github-Profile-Cloner

PD: no me cloneis mi cuenta porfa :(

[removed]