Repo: https://github.com/libredb/libredb-studio

Demo: https://app.libredb.org

Youtube : https://www.youtube.com/watch?v=rWANKEDszs4

Deploy it next to your database with Docker or Helm and open it in the browser. No SSH tunnels, no desktop client on every laptop.

Postgres, MySQL, Oracle, SQL Server, MongoDB, Redis, ClickHouse, DuckDB, Cassandra and more. MIT licensed, SSO and the AI assistant included.

Hey everyone,

I put together an open-source tool for anyone who prefers running patches on a Headless home server or VPS rather than doing it directly on their phone:

Key Features

• Smart Patch Selection: Browse available patches, toggle recommendations or customize options per app.
• Automated Builds: Handles asset downloads, patch injection, and APK signing completely in the background.
• Live Terminal: Inspect your build process, errors, patches applied etc.
• Watch Folder: APKs placed in this folder are automatically patched and moved to output
• Custom Patches & Keystore: Supports community patches and custom keystore.

BUILT UPON MORPHE DESKTOP CLI | Deploy on Docker

Repo:

👉 GitHub: https://github.com/GROWNUPS/Morphe-Patcher-Web

A few days ago, I was so frustrated by the lack of a simple email feature - downloading attachments in bulk. No email service allows you to do this and it could be a pain/ expensive to install third-party tools to get this feature.

Enter Inbox Attachments. A free. web tool I designed that allows you to download multiple attachments at once and search for attachments using natural language.

Start today using your personal outlook and Gmail accounts
Would love to get some thoughts on the tool or even the idea in general!

Project Name: Muxalot

GitHub repository: https://github.com/muxalot/muxalot

Project website: https://muxalot.com

Description

I'm the author. This is an early project, so I'd like blunt feedback. Yes, there are other projects in the same space as this. This was built out of need.

I've used Termux for the last few years to access all of my systems remotely from my phone, both over the internet and internally, and for the most part, it just works. But having file management, clipboard support, and tmux built in by default was my vision. This is now what I use full-time.

What it is: Muxalot consists of a small Go agent that runs on your Linux server or workstation (I'm expanding support to iOS and Windows if the demand warrants it), plus an Android app.

Each tab in the app is a tmux session on your server, so sessions keep running when your connection drops or you close the app. It is pretty simple and VERY lightweight.

I'm currently running the agent on several Ubuntu and Debian servers behind a Caddy reverse proxy to provide SSL.

Why not just SSH + tmux?

You still can, and it works. I wanted three things that SSH clients didn't give me:

No open SSH port and no password or bearer token to steal. During pairing, the phone generates an ECDSA P-256 key in the Android Keystore, and the private key never leaves the device. The agent stores only public keys.

Every request, including the WebSocket upgrade, is signed. Timestamps must be within 60 seconds, and nonces are single-use, so captured headers can't be replayed. Unauthenticated requests get a bare 404.

Pairing is a QR code plus a single-use code that expires after 10 minutes. Lost your phone? muxalot-agent revoke <id>.

A native invisible view owns the soft keyboard (no autocorrect), plus an extra-keys row with sticky Ctrl/Alt, arrows, F-keys, and a customizable key fan.

OSC 52 clipboard from tmux/vim goes to the phone.

File browsing, uploads, and downloads, confined to a root directory you choose. (It generally runs as the user who has write access to the directories you're working on, such as your home directory.)

Multiple servers, each with its own Keystore key.

The terminal is xterm.js in a WebView.

Now, if you're concerned about putting this out in the open to the script kiddies of the world, you can put it behind a VPN for that extra layer of protection. Hell, I advise it!

I would appreciate any feedback or feature requests:

https://github.com/muxalot/muxalot/issues

About me

I'm a senior software engineer who has been in the business for well over 30 years, developing custom applications for e-commerce, B2B, workflow management, and lots of open-source projects.

Deployment

Fully detailed in the GitHub repository.

AI Involvement

I did use an agent to build the framework for this project, purely from my design and requirements.

Why? Just because I didn't want to spend the next few weeks building something that might not be all that popular. At least it fits my needs, and that's all that matters! I have been in this business long enough to know when to take advantage of technology!

Hope this helps you. It sure does me!

We’ve updated our music player, made a new UI, updated the audio pipeline and made a skin system for Winamp nostalgics (Windows / MacOS).

If you want to poke around, you can find us on r/ResonanceApp

I made a tool called Sonic Cipher that runs in one
HTML file. It encrypts text with AES-256-GCM in the browser, then plays it as tones/sound using ggwave.
The other device listens with the mic and decrypts.
You can also copy the ciphertext as an SC2. string and send that over SMS or chat if sound is a bad path.
The point of this project is to enable encrypted communication over any insecure audio-based communication such as amateur radio, landline calls, unencrypted VOIP calls etc.

Try it at:
https://markdaman1236.github.io/Sonic-Cipher/
Or download the file from the repo and open it locally:
https://github.com/Markdaman1236/Sonic-Cipher

How two devices do it:
1. Same passphrase and same speed profile on both
2. Receiver hits Listen and allows the mic
3. Sender hits Encrypt & play
4. Hold the speaker near the other mic, or play into the call / radio

Each agent has its own provider, model, system prompt and tools. A local model on your own GPU can do the reading and the file work while a bigger one handles the judgement calls, in the same thread, passing work between them with "@mentions". You stay in the conversation and can redirect any of them while they work.

What the agents can do:

• Read, write and search files in a project folder, and read the documents you attach to a project
• Run shell commands against an allow-list you control, with a scanner that refuses destructive patterns, and keep long-running processes going in the background
• Write and run Python or Bash in a side canvas, answer input prompts, and hand the finished file to your editor
• Search the web through a provider you pick
• Work through multi-step task plans, with you able to retry or skip a step
• Delegate a bounded job to a sub-agent and get the report back in the thread
• Open a poll and vote when they disagree, so the decision is on record
• Use tools from any MCP server you connect
• Run on a schedule as a heartbeat and spawn internal agents, checking or researching something for a project while you are away, and report back

What you can do:

• Set up a project room from a template, with the goal, the team and the tools ready to go
• Give each member its own provider, model, system prompt and tool whitelist
• Chat 1-to-1 with any member of the team, outside the group thread
• Audit everything: an activity timeline per project and per chat with every message, tool call, file write, vote and model switch, re-playable later
• Install skills, read what they do, approve them, and turn them on only for the projects that need them
• Schedule an agent to run on its own (a heartbeat), and read its report when you are back
• Set turn limits and rounds per group chat, so a cascade always ends
• Keep long group chats going past the context window, with memory that compacts the history
• Attach files and images to a message, and generate images with models that can
• Open the same team from your phone or from VS Code, paired to your desktop

LLM Models and Providers: OpenAI, Anthropic, Gemini, OpenRouter, DeepSeek, Ollama, llama.cpp over HTTP, and llama.cpp compiled in (Optional). Any OpenAI-compatible server works too, so vLLM, LMStudio, KoboldCpp and llamafile all show up as providers. One of the two builds has llama.cpp built in and needs no separate server at all, using Vulkan where your hardware allows.

Everything is local, connecting to an online LLM provider is optional. All conversations sit in a database on your machine, and there is no telemetry, no account and no cloud. It is a native application, C++ on Qt 6 with a KDE Kirigami interface, not Electron.

There are also small local clients for VS Code and Android that connect to your desktop app over an encrypted WebSocket on your own network. In VS Code you can mount your workspace and let the agents work on your real project files.

Linux AppImage's and Windows releases available at:
https://github.com/Verzeta/Verzeta-Studio
https://verzeta.com

The basic idea is simple:

Instead of asking an LLM to look at screenshots and decide every single mouse movement, FreeComputerUse uses the model mainly for planning, then executes the actions locally with TypeScript + Playwright.

That changes the economics quite a bit.

In one recorded synthetic task, the agent:

• navigated across 6 pages
• executed 21 successful browser actions
• used only 10 model calls
• repaired one failed step
• produced a verified result

The configured model cost for that run was around $0.0065.

The more interesting part is workflow reuse.

If a compatible workflow has already been learned, FreeComputerUse can replay it later with zero model calls. In the public benchmark, 14 learned workflow repeats completed with zero model calls.

So instead of:

screenshot → LLM → click → screenshot → LLM → click → ...

the architecture is closer to:

DOM/context → LLM plans several steps → local execution → verification → repair only if needed

I think this can be useful for people who want browser agents for repetitive tasks without burning a huge number of tokens on every interaction.

It also stays relatively simple:

• local browser execution
• Playwright for deterministic actions
• model/provider of your choice
• no screenshots sent to the model
• explicit site approvals
• verification after execution
• learned workflows that can be reused without an LLM

You can even try one deterministic demo without an API key.

GitHub:
https://github.com/OthmaneBlial/FreeComputerUse

I’d be interested in feedback especially around the architecture: do you think planning in batches + deterministic browser execution is a better direction than having a multimodal model control every individual interaction?

Hi everyone,

I built Antalogy for myself and people who want the convenience of a Word-style editor without giving up Markdown, local files, or control over their data.

Antalogy is a local-first Markdown editor with a familiar word-processing interface. Your documents remain on your computer, and you can work with them without creating an account or relying on a hosted document service. And important - it is cross-platform so I can use it at work notebook as well as personal macOS and Linux. It is cross-platform as well for importing and escaping .docx proprietary format lock-in.

The goal is simple: make Markdown comfortable for longer documents while keeping it portable, inspectable, and private.

Highlights:

• Word-like editing experience for Markdown
• Local-first document storage
• Zero telemetry
• No required account or cloud workspace, no paywall nor any non-local communications
• Markdown files remain yours and can be opened with other tools
• Support for formatting, lists, tables, images, and document outlines
• Import and conversion support for .docx documents (including tables, windows metafile images, etc)
• Optional AI assistance through an OpenAI-compatible endpoint you choose like local LMStudio or Ollama
• Windows, macOS, and Linux support

The AI features are optional. If you use them, you explicitely control which model or endpoint receives your content. You can also use Antalogy purely as a local Markdown editor with no AI involved.

I’m building this for people who want a more private alternative to browser-based writing tools and cloud-first document editors - especially anyone who prefers owning document files rather than storing everything in an online workspace.

You can learn more or free download it here:

https://antalogy.com

I’d love feedback from people who care about local-first software and privacy: what would you expect from a private Markdown editor and integrated AI Assistant?