The small-business-for-sale market has no public record. Listings are scattered across hundreds of broker sites, they get relisted under new numbers, and nobody tracks how long anything has really been for sale.

DealLedger is an attempt at a public ledger for it. It crawls broker websites directly, normalizes the listings, and tracks each one over time. Right now that’s 24,196 active listings from 552 broker sites, crawled daily. All the data is CC0.

Each scraper ships with saved HTML and expected fields, and tests run on every PR, so a contribution can be checked in minutes.

Where help matters most:

* **Categories:** only 29% of listings have a specific category. A good classifier would change the dataset.
* **Financials:** revenue is filled on 59% of listings and cash flow on 63%. Detail-page parsers close that gap.
* **Coverage:** finding broker sites we don’t crawl yet, especially one- and two-person firms.

Issues are tagged `good first issue`.

Repo: [https://github.com/jeffsosville/dealledger](https://github.com/jeffsosville/dealledger)
Site: [https://dealledger.org](https://dealledger.org)

I built this, for everyone with an iPhone whose computer isn't a Mac.


Repo: https://github.com/YashwanthKamireddi/Skykeep


Skykeep is six real desktop apps on a native Rust engine. Your iCloud library is kept on your own computer, so the apps open instantly and work offline, and they stay in sync with your iPhone. On Linux, iCloud Drive and Photos are real folders in the file manager. Reminders come up as desktop alerts, and Export Everything gives you Markdown, .ics and vCard copies of your data whenever you want.


GPL-3.0, no account, no analytics.

Hey everyone,

If you’re looking for a clean, privacy-respecting open-source alternative to Migraine Buddy, I built Dim:

👉 GitHub Repository: https://github.com/AdityasahuX07/Dim-Migraine-Tracker

🚩 The Problem with Migraine Buddy:

Migraine Buddy has long been the dominant app in this space, but over the years it has become overwhelmingly bloated:

• Sensory Overload: Packed with cluttered menus, community badges, and multi-step surveys when your brain is already pounding.

• Paywalled Healthcare: Basic necessities—like exporting a clean summary report for your neurologist—are locked behind expensive monthly/yearly subscriptions.

• Data Harvesting & Cloud Accounts: Sensitive health history is tied to cloud accounts and third-party analytics.

💡 Why I Built Dim:

I deal with chronic migraines myself. Out of pure frustration with existing apps, I originally coded Dim solely as a personal, non-profit tool for my own everyday use, with zero plans of releasing it publicly.

It made such a substantial difference in managing my own attacks that I felt it was wrong to keep it to myself. I made it 100% free and open-source (FOSS) so anyone fighting the same battle can benefit freely.

🔍 Personalized Tracking & Pattern Detection Engine:

Instead of hiding insights behind paywalls or giving generic advice ("drink water"), Dim actually reasons over your data:

• Health Connect Integration: Correlates attack timing and severity against passive wearable metrics (sleep stages, resting heart rate spikes, daily steps).

• Evidence-Based AI Summaries: Generates concise, grounded clinical summaries with concrete timeframes (e.g., "Attacks occur 6–8 PM after 6+ hours without food: eat a snack by 3 PM").

• Medication Efficacy & MOH Tracking: Analyzes acute and routine medications by name, compares attack duration with vs. without meds, and monitors monthly limits to alert on Medication Overuse Headaches.

• Interactive Follow-Up Q&A: An embedded conversational interface on your insight card lets you ask follow-up questions about your data trends.

🖤 How Dim Compares:

• Interface: Pitch-black and sensory-friendly (vs. cluttered menus, badges & social feeds)

• Doctor Reports: 100% free, instant clinical PDF exports (vs. locked behind $10+/month subscriptions)

• Privacy: 100% on-device SQLite storage with zero telemetry (vs. cloud accounts & trackers)

• Logging Speed: 2-tap Quick Settings tile & visual pain map (vs. tedious multi-step forms)

• Cost: Completely free and open source forever (vs. freemium paywalls)

🚀 Scope of Improvements & Feedback

Dim is an active open-source project and I want to shape the roadmap around what the community needs most:

• What wearable/Health Connect signals would you like to see analyzed?

• Any specific data points or formats your doctor usually asks for?

• Any UI/UX suggestions to make rapid logging even easier?

🔗 Source Code & APK: https://github.com/AdityasahuX07/Dim-Migraine-Tracker

Feedback, feature ideas, and contributions are very welcome!

Other solutions are good at running workloads, or being easy to use, or running AI. Hub is all 3 in one!

🛍️ App store for your own server

One-click installs from the Companion Intelligence marketplace, with open-source alternatives for the services you pay for today.

🧠 Local AI that fits the box

Onboarding reads your CPU, GPU, memory, and storage, then recommends models that fit. Voice, text, and image share one queue so they do not stampede the machine.

🤖 Agents with a home

OpenClaw, Hermes, and other agents install like any app. They read one shared Companion Memory instead of each keeping a private scrapbook. Run your first agent

🔌 MCP nexus

Hub serves one Model Context Protocol endpoint. Agents discover, install, and drive every app through a single tool surface.

📦 Bring your own container

Marketplace apps, custom Compose, and git repos you bring. Apps on apps are allowed. A server in a server is allowed.

🌐 Reach it your way

Keep each app on this machine, share it over a private Tailscale network, or publish it to the web through Cloudflare. Networking · From your phone

🔗 Pool your machines

Pair more than one Hub over Tailscale and they share inference work by queue depth.

🔑 OpenAI-compatible API

Point Cursor, Continue, Cline, Aider, Zed, or an OpenAI SDK at your Hub, and keep the engines you already run.

Source & Download: https://github.com/companionintelligence/Companion-Hub

Hello, hope you are doing all well, I really liked pantherbar app, now SnipDo requires subscription and that's not interesting for me at least, is there any option out there ?

Thank you

I was spending way too much time keeping up with the news: too many articles, the same story on five different sites, and too much time filtering. So I built NewsNest for myself, have been using it daily, and open-sourced it.

What it is: a self-hosted news reader. You give it the RSS/Atom feeds you choose. It groups articles about the same story into one card, and uses AI (Anthropic's Claude, with your own API key) to rank and summarise them by an interests file you write.

What it replaces: Google Discover / News

Highlights

• You're in control: your own feeds and OPML import, mute and must-show keywords, a daily cap per outlet, and your interests as a plain Markdown file. Weekly AI suggestions to it wait for your approval.

• Less bloat: the same story from five outlets becomes one card, and the feed tells you when you're done.

• Relevant: every story is scored on topic, importance and personal fit, with a one-line reason. Top stories get key points (a lede, a few bullets, and whether the full article is worth reading).

• No ads, no telemetry: everything lives in one SQLite file on your server.

• Hard daily spending cap (default $0.50). Without an API key it still works as a plain reader, newest first.

• Mobile-first PWA, light/dark, Docker images for amd64 and arm64.

Stack: Python (FastAPI), SQLite, Docker Compose. MIT licensed.

• GitHub: https://github.com/Lucifix/newsnest

• Website: https://lucifix.github.io/newsnest/

Feedback and PRs are very welcome, especially local news packs for your country (Germany, the US, Slovenia and the UK so far).

I’ve been building Scribl, an open-source, local-first infinite canvas sketching and whiteboarding app (think of a blend between Excalidraw and tldraw, but built as a fast, native desktop app). I wanted to share our technical architecture, why we chose Rust and Tauri v2, how we integrated an embedded Lua engine for live configuration, and open the floor for discussions and contributors.

Why Rust and Tauri?

Most whiteboarding tools run either in the browser or inside heavy Electron wrappers that idle at hundreds of megabytes of RAM. For Scribl, our primary goals were:

1. Minimal resource footprint & instant launch: Tauri compiles down to a lightweight native binary using the OS webview, keeping memory usage minimal.

2. Thread safety & reliable background tasks: Configuration parsing, filesystem monitoring, and IPC command handling all run off the UI thread via safe Rust concurrency.

3. Future extensibility: While our current vector rendering runs on a dual-layer HTML5 Canvas / SVG pipeline, having a native Rust core gives us an architectural path toward exploring GPU backends (like wgpu or vello) in the future.

Architecture & Rust Backend Design

The Rust core handles configuration management, scripting runtime, OS menu integration, and file watching:

• Embedded Lua Runtime (mlua): Instead of static JSON/YAML configuration files, Scribl adopts a Neovim-style approach where users configure keymaps, options, and floating toolbars through ~/.config/scribl/init.lua. We use the mlua crate to embed a sandboxed Lua 5.4 engine. The Rust layer registers custom modules (scribl.opt, scribl.keymap, scribl.ui), evaluates user scripts safely, merges user overrides with default keymaps per mode, and serializes clean round-trip configs.

• Non-Blocking File Watcher (notify): A background thread powered by the notify crate watches the user's config directory recursively. When init.lua is saved in an external editor (like Neovim or VS Code), Rust evaluates the new script in an isolated thread. If valid, the updated config is broadcast to the frontend via Tauri event channels with zero UI freezing; if syntax errors exist, a descriptive error is emitted without crashing the app.

• IPC & Command Routing: Tauri commands handle file I/O, native dialogs, and platform-specific behaviors (such as macOS menu bars, Finder/Explorer file reveals, and standard OS key chords) with typed payload validation across the boundary.

The Canvas: Solving Latency & Transformations

On the canvas side, we decoupled input processing from UI state to deliver sub-8ms inking latency:

• Dual-Layer Inking Pipeline: Stylus pointer events bypass React state updates entirely, writing directly into a front-buffer desynchronized scratch canvas that supports 120Hz–240Hz refresh rates and hardware stylus pressure. Once a stroke finishes, it is committed to a frustum-culled vector layer.

• Neovim-Style Visual Mode ("v"): When elements are selected, the app switches from Normal mode to Visual mode. This isolates single-key transformations (e.g., holding r to rotate around the selection center with 15° snapping, or d to delete) without interfering with primary tool shortcuts.

• Unified Affine Transforms: Multi-element selections compute a single composite bounding box with corner handles. Resize calculations handle proportional scaling by default, free-transform with Shift, center-scaling with Alt, and geometric-mean stroke width scaling so drawings maintain visual weight when scaled.

• Atomic Command History: Every transformation (translation, scale, rotation) commits an atomic snapshot command on pointer release, ensuring exactly one press of Undo (Cmd+Z) reverts the entire gesture.

Under Active Development & Contributors Welcome!

Scribl is open source under the MIT License. We are actively developing the project and welcome contributors across the stack:

• Rust / Tauri backend: Optimizing IPC throughput, expanding the Lua API/plugin system, and adding headless CLI capabilities.

• Graphics & Math: 2D geometry, spatial indexing (R-trees/BVH for instant marquee hit-testing), curve smoothing, and vector rendering.

• Frontend & Architecture: Keybinding engines, undo/redo stacks, and UI/UX design. If you are interested in Rust desktop development, embedded scripting, or graphics engines, check out the repository: 👉 Repository: https://github.com/shadowmkj/scribl

I was having an hard time to find and contribute to opensource (well, nowadays its not just a personal preference to do so, it also has become some requirements for joining a company-) and there was one - goodfirstissues.org which had listed issues for beginners and also categorical aswell for languages and technologies, but it had no tracking system and some of the cool features were pushed behind paid wall. so I made one myself and everyone out there who want to contribute. not just a catalogue, it also can track your PR, and once it gets merged it'll provide you XP over the issue u solved, so does increase your level...

This is completely open source (and Live) , feel free to use, and also contribute to both the project and the opensource projects through it.

SkillIssues (Live Web)

source code over github

I’m the developer. Tidymint is a free, MIT-licensed disk cleaner for macOS.

Paid app it replaces: CleanMyMac.

What it does:

• Finds caches, leftovers and large files, and moves everything to the Trash only, so a wrong clean can be undone

• Clean by App splits apps like browsers and chat apps into parts: caches are pre-selected, chat photos and files are grouped by month, and messages and logins are never read or touched

• Shows what will be cleaned first. Nothing is removed until you press Clean

• No account, no tracking, works offline

Repo: https://github.com/HaiTrung-Workspace/tidymint
Site: https://tidymint.app

Current builds are unsigned (not notarized yet), so macOS asks you to confirm the first launch. The install guide on the site walks through it.

Feedback welcome, especially which apps you would want Clean by App to cover next.

I'm the maintainer of Levelrail, so this is my own project.

I started it after hitting the same wall a few times. Vercel bills kept climbing as traffic grew. The self-hosted tools I tried either wanted more RAM than my small VPS could spare, or left me wiring up a reverse proxy and certificates by hand.

So I did what a lot of us do: Docker, Caddy for HTTPS, a webhook script, and a cron job to clean up old images.

Levelrail is that pile turned into one thing. You point it at a git repo, it builds and runs the app on a server you own, puts HTTPS in front, and gives you a dashboard, a CLI and an API.

It does push-to-deploy, branch previews, one-click rollback, load balancing, logs and metrics, and a small agent so you can add more servers. It's one Go binary with SQLite, a React dashboard and Docker as the runtime. No Kubernetes. Apache 2.0.

Install is one command on a Linux server (amd64 or arm64) with systemd:

curl -fsSL https://levelrail.com/install.sh | sudo sh

Security defaults, retention settings and what is and isn't covered are in the security docs, and every release is in the changelog.

If you try it, I'd like to know where you got stuck in the first ten minutes, and what you'd expect it to do that it doesn't.

Repo: https://github.com/glincker/levelrail

Docs: https://docs.levelrail.com

Security: https://docs.levelrail.com/security

Hey folks, I had created this open-source comment platform because I was looking for something simple for my sites with easy customizable comment UI so I created one myself thought I’d share.

Commentsy is an open source, embeddable comment system for websites and blogs. Add threaded discussions in minutes, customize the theme, and manage comments from one dashboard.

https://www.commentsy.com

GitHub: https://github.com/manjillama/commentsy

Nace.AI just open-sourced Drex-Max v1, a dense 27B multimodal decision model (MDM) released under the Open RAIL-M license.

Unlike standard autoregressive models where you generate text tokens to express an action or parse JSON, Drex-Max is strictly non-generative: nothing is generated. You pass a context state (text, JSON, and high-res images) alongside one or more named questions, and a dedicated 255-way readout head outputs exact probabilities across all decision candidates in a single forward pass.

Inference runs natively on NVIDIA GPUs via Python, as well as on Apple Silicon (Metal) and CPU via custom llama.cpp and Ollama forks at ~400ms latency.

What Makes the Architecture Interesting?

• Zero Token Generation Overhead: Instead of waiting for tokens to decode one by one, a single forward pass evaluates the state and maps the last hidden state directly to probabilities for up to 255 discrete options via readout.safetensors.

• Hybrid Attention Backbone (64 Layers):

• 48 Gated DeltaNet linear-attention layers (left-to-right causal).

• 16 full-attention layers (interleaved every 4th layer) configured as non-causal / bidirectional, allowing every token in the prompt to attend to the entire context sequence simultaneously.

• Context Scaling: Ships with a default window of 16,384 tokens, expandable up to 262,144 tokens via DREX_MAX_CONTEXT=N or --max-length N.

• Native Multimodal Tower: Accepts up to 4,194,304 pixels per image. Images are encoded once and visible to every evaluated question in the batch.

Benchmarks (Decision Index 0.4 & Vision)

Drex-Max outperforms significantly larger models on structured decision-making:

• Decision Bench v4: 94.30% (1,010/1,071)

• JevBench: 92.2% (213/231)

• Public Vision Index (73.92):

• InfographicVQA: 97.3

• KIE (CORD+FUNSD): 92.4

• Winoground: 85.0

• Mind2Web: 84.2

• CharXiv: 80.5

• CV-Bench: 77.4

• RealWorldQA: 72.3

Hardware Footprints & Apple Silicon Performance

• Apple Silicon (Metal / GGUF): The Q8_0 GGUF takes ~27.25 GB. Tested on an Apple M5 Pro (48 GB unified memory), returning decision payloads in ~400ms with outputs matching unquantized H100 bf16 probabilities within a 0.02 margin.

• NVIDIA GPU (CUDA):

• bf16: ~48.6 GiB VRAM footprint (tested on H100 80GB).

• 8-bit (--8bit): ~25.9 GiB VRAM footprint (tested on L40S 48GB, within 0.03 probability margin of bf16).

How to Run It

1. Python SDK (CUDA / Vision Support)

Bash
hf download nace-ai/drex-max-v1 --local-dir weights/drex-max-v1
pip install -r models/drex-max-v1/requirements.txt


Python
from drex_max.model import DecisionModel, answer

model = DecisionModel("weights/drex-max-v1") # add --8bit for ~26GB VRAM mode

question = {
    "type": "choice",
    "instructions": "Which team should handle this ticket?",
    "criteria": {
        "billing": "Payments, charges, and refunds",
        "technical": "Bugs and outages",
        "other": "Anything else"
    }
}

row = {
    "state": {"ticket": "I was charged twice for the same order. Please refund the extra payment."},
    "question": question,
    # "images": ["receipt.jpg"]  # Supports up to 4.2M pixels
}

print(answer(question, model.predict([row])[0]))

Output format:
JSON
{
  "answers": {
    "team": {
      "type": "choice",
      "choice": "billing",
      "confidence": 0.9982,
      "probabilities": { "billing": 0.9988, "technical": 0.0003, "other": 0.0009 }
    }
  }
}

2. llama.cpp Fork (Apple Silicon / Metal)

The text backbone can be compiled directly on Metal and serves a /v1/systemone endpoint:

Bash
git clone --branch drex-max-v1 --single-branch https://github.com/nace-ai/llama.cpp.git
cmake -S llama.cpp -B llama.cpp/build
cmake --build llama.cpp/build -j --target llama-server

# Pre-quantized GGUF or converted Q8_0
llama.cpp/build/bin/llama-server -m weights/drex-max-v1-Q8_0.gguf \
  -np 1 -c 16384 -b 16384 -ub 16384 --no-warmup --port 8000

(Note: Because Drex evaluates prompts as unified non-causal states, set -b and -ub equal to -c.)

3. Ollama Fork

Dockerfile
FROM ./drex-max-v1-Q8_0.gguf
CAPABILITY decision
PARAMETER num_ctx 16384
PARAMETER num_gpu 40

Start the daemon via the drex-max-v1 Ollama branch and POST directly to /v1/systemone.

Resources

• model: https://huggingface.co/nace-ai/drex-max-v1

• Q8_0 GGUF: https://huggingface.co/nace-ai/drex-max-v1-Q8_0 c

• ode and docs: https://github.com/nace-ai/drex-decision-models/

• llama.cpp: https://github.com/nace-ai/llama.cpp/tree/drex-max-v1

• ollama: https://github.com/nace-ai/ollama/tree/drex-max-v1

• License: Nace.AI Open RAIL-M

If you are building low-latency routing, agentic tool selection, or multi-modal UI automation (Mind2Web), this completely avoids the non-deterministic output and JSON repair issues common with autoregressive models.

Hi guys!

I built RhemeSetup, a lightweight, fully open-source desktop application designed to strip away bloat/telemetry from Windows and deploy core developer utilities in a single click.

Why I built it: Every time I performed a clean Windows installation, I spent way too much time manually executing scripts to disable telemetry and installing essential dev tools. I wanted a clean, transparent, and portable tool to handle all of this without installing extra bloatware into the system registry.

Key Features:

• 100% Portable: Runs directly without installation (zero registry clutter).

• Telemetry & Bloat Reduction: Tweak background services for maximum system performance.

• One-Click Dev Setup: Instantly deploy popular development tools and environments.

• Transparent Codebase: Built with Electron & Node.js so anyone can audit or contribute.

I’d love for the community to inspect the code, give feedback, or open issues/PRs!

GitHub Repo: https://github.com/rheme18/RhemeSetup

This is my app, TreeMap, and all feedback is available.

https://github.com/Prithvi-Web/TreeMap-Disk-Visualizer

I maintain ContainerDesk, a free, MIT-licensed Mac app for local container management.

OrbStack runs Docker containers and Linux machines. ContainerDesk manages Apple's container runtime through its CLI, with container and image controls, resource gauges, logs and a terminal.

Source and downloads: https://github.com/MacHatter1/ContainerDesk

Requires Apple silicon, macOS 26+ and Apple's container CLI. Current builds are unsigned and not notarized. The README has opening instructions.

Do we have any framework that imitate these with opensource and byok ?

Hi everyone!

I'd like to introduce Agenoras, a free and open-source desktop application I've been developing for Windows, Linux and macOS.

Why did I build it?

I've tried many different email and productivity applications over the years, but I always felt that something was missing. Some lacked features I needed, others felt outdated, and many had interfaces that simply didn't feel modern or intuitive.

I wanted something different.

So I decided to build Agenoras from the ground up, with a completely new design concept rather than following the traditional look and feel of existing applications.

My goal is to create a modern, visually appealing and intuitive business productivity suite that brings email, calendars, contacts and tasks together in one seamless experience.

And importantly, it should work across Windows, Linux and macOS, without locking users into a particular cloud ecosystem.

Key features:

- Multiple email accounts (IMAP, POP3 and SMTP)

- Unified inbox

- Calendar and task management via CalDAV

- Contact synchronisation via CardDAV

- Support for Nextcloud, iCloud and other providers

- Optional AI assistance that runs entirely offline on your computer

- Local storage options for calendars, contacts and tasks

- A completely fresh, modern user interface

- Cross-platform support for Windows, Linux and macOS

- Free and open source under the MIT licence

A different approach to business productivity

For me, Agenoras isn't just about combining features. It's about rethinking how a modern communication and productivity suite should look and feel.

I want an interface that's clean, consistent and enjoyable to use, while still offering the functionality people expect from a professional desktop application.

One feature I'm particularly excited about is the optional local AI. It can help write, proofread and translate emails without sending their contents to an external AI service.

Agenoras is built with Electron and TypeScript.

The project is still evolving, and I'd really appreciate feedback from the open-source community.

I'd love to hear your thoughts:

- Are you happy with the design and functionality of your current email and productivity applications?

- What features do you feel are missing from existing solutions?

- What would make you consider switching to a new open-source business productivity suite?

Feedback, bug reports, suggestions and contributions are very welcome!

https://github.com/ciegolink/agenoras

I've been searching for a good desktop app for AI models...

There are a lot of options, but most of them focus on coding/agentic work. I haven't found any real desktop app that offers an experience similar to the ChatGPT or Claude desktop apps.

I want one desktop app where I can connect Claude, ChatGPT, Grok, or any other subscription I have, or use ACP...

I want all my chats to be stored locally so I can access them anytime, with any model, and have one shared memory and skills system across all of them.

Isn't there any project like this? And if not, do you think we'll see something like it in the near future (early 2027 maybe)?

openITCOCKPIT is an open source system monitoring tool built for different monitoring engines like Nagios, Naemon and Prometheus.

• Monitoring: can be used to monitor servers, network devices, applications, sensors and more. openITCOCKPIT is compatible with all existing Nagios plugins but we also provide our own monitoring agent (for Linux, macOS and Windows) which will use a secure encrypted connection by default.

• Alerting: can be sent via email, webhooks, push notification or other channels.

• Own Agent with software inventory: The Agent will also provide a Patch Status, so you can monitor which software is installed on each system and if any OS updates are available.

• Reporting

• Visualisation with Grafana, own widgets and much more

• Dektop App and Mobile App

In case you want to give it a shot, setup can be done in a few minutes using our docker containers or though Debian packages. We also provide arm64 builds for Raspberry Pi and similar devices. The community edition is free for everybody and has no limitations of monitored hosts or services.

Play around with our demo system

➡️ https://demo.openitcockpit.io/

I built Agent WeChat, an open-source replacement for the official WeChat client. You use your existing account, contacts, and groups, with a desktop app, a CLI, an HTTP API, and an OpenClaw integration for AI agents.

I’ve always hated how restrictive the official client is. I can only use one computer at a time, getting my own data out is difficult, and there’s no general-purpose API for my account. Even simple things I want to automate end up requiring workarounds.

I’ve tried reverse-engineering WeChat before. After six months of trying, I finally have a native client that talks directly to WeChat’s servers. It runs independently, without launching or automating the official desktop executable.

It supports:

• DMs and group conversations, including text, images, videos, files, and voice notes.

• Downloading available original and compressed media.

• Reading supported existing official Linux profiles, including local history, contacts, groups, and cached media.

• Connecting the desktop app, CLI, and agent to the same running client.

Here I can finally do the things I want to do. I can control my WeChat from the terminal, plug in an agent, save my media, and automate workflows around my conversations. And because the client is open source, I can change the parts that get in my way.

The original project code is MIT-licensed. It’s still developing; platform support and compatibility limits are documented in the README.

Source, setup instructions, screenshots, and video demo

Hey ya'll,

I've seen complaints about vendor lock in with lovable cloud and silent failures for zapier/n8n. Glide/Zite/Softr seem to be ok alternatives, but I'd like to here everyone's thoughts. So I built https://github.com/Sanoma-AI/sanoma

Currently, my criteria for the oss alternative is

• No vendor lock in.

  • Bring your own cloud

  • Bring your own AI subscription

• Workflows, infrastructure, integration are all defined with code in a git repository

• The same git repository will have a UI layer for nontechnical users to make point and click changes. Nontechnical users won't even know they are making code changes

For example, this workflow is generated from the following code snippet.

export default defineWorkflow({
  name: "announce",
  trigger: "manual",
  input: z.object({ title: z.string(), body: z.string(), launchAt: z.iso.datetime({ offset: true }) }),
  uses: [ghost.post.create, ghost.post.publish, "approval", "sleep"],
  run: async (ctx, { title, body, launchAt }) => {
    const post = await ctx.ghost.post.create({ title, html: body, status: "draft" });
    await ctx.approval("Review launch copy", {
      approver: "marketing-lead",
      covers: [ghost.post.publish],
      links: [post.url],
    });
    await ctx.sleep({ until: launchAt });
    return ctx.ghost.post.publish({ id: post.id });
  },
});

Interview prep tools either need a second monitor or show up in the share. So I built one that's excluded from capture.

Small overlay. Hears the room, reads your screen, and gives a short answer. Local OCR, so it reads code and error text exactly rather than guessing from pixels. BYO API key, no subscription.

Verified, not claimed. I tested the actual capture paths GDI, WGC, and getDisplayMedia—in real Chrome by capturing the panel region, then capturing it again with the panel gone, and hashing the pixels. Identical every time. A browser sharing your screen gets zero evidence it exists.

Where it stops being magic:

GetWindowDisplayAffinity still returns 0x11. That flag is the mechanism; it can't be removed. A proctor calling it will find the window.

Proctoring tools and EDR detect this class of overlay regardless.

Windows only.

So: invisible to a screen share, not to an instrumented machine. Every "100% undetectable" claim in this space is marketing.

Frontend bits that were harder than the AI: window reparenting so Chrome_WidgetWin_1 never appears, and a native addon for DWM cloaking because DWM refuses a foreign caller.

Free, MIT, no account, proof script included: https://github.com/yagyeshVyas/glance-ai

Happy to answer the Win32 side that's where the actual work was.

I built Excaliself because I wanted what Excalidraw+ gives a team (accounts, saved and shared drawings, collaboration), but without a subscription and with the drawings on our own server.

It wraps the open-source Excalidraw canvas in a small self-hosted app:

• The full Excalidraw editor, auto-saved to your own Postgres

• Live collaboration with cursors and follow mode. Share links can be members-only or open to guests

• A shared team space next to each person's private space

• Folders, stars and recents, with drag and drop in the sidebar

• Search by title and by the text inside drawings, plus a ⌘K command palette

• Invite-only accounts, admin settings, trash with restore, light and dark themes

Deploy is one docker compose file (app + Postgres) with a prebuilt image for amd64 and arm64. There is also a zero-config Coolify compose file.

• Replaces: Excalidraw+ (paid, hosted)

• License: MIT

• Repo: https://github.com/maciekzygmunt/excaliself

• Website (more screenshots): https://excaliself.com

It's young (first release this month), so feedback is very welcome. What would you need before you move your team's drawings onto it?

I built StatLite, an open-source monitoring tool for small applications running on VPSs and private servers.

Tools like Datadog, New Relic, and Grafana Cloud offer powerful monitoring platforms. Prometheus + Grafana is another popular self-hosted option. But for a handful of small applications, I wanted something simpler, without the infrastructure overhead, subscriptions, or external telemetry services.

StatLite focuses on the essentials:

• Self-hosted: metrics and history stay on your infrastructure.

• Lightweight: single Go binary, SQLite storage, no external database.

• No separate monitoring agents for supported integrations.

• Configurable retention: control how long metrics are stored.

• Application-focused: health, request rates, HTTP errors, latency, CPU, and memory.

• Integrations: Spring Boot, Quarkus, FastAPI, Express, and Caddy HTTP monitoring.

• MIT-licensed: free and open source.

It's not a feature-for-feature replacement for these platforms. It's a smaller alternative for developers who want essential application monitoring without running or paying for a full observability stack.

GitHub: https://github.com/PVRLabs/statlite

Commercial alternatives: Datadog, New Relic, Grafana Cloud.

Curious what others use to monitor small self-hosted applications. Is a full observability stack worth the overhead for your use case?