Self-Hosted AI

How a Rust daemon uses Git worktrees and socket proxies to build the isolated sandboxes necessary for parallel AI coding agents.

How Dify extends its platform without letting subprocesses, Python dependencies, and runtime isolation leak into the core server.

MathWorks solved the GUI gap by turning a heavy desktop suite into a lightweight Jupyter resident.

A look at how BaoLianDeng intercepts flows at the socket layer, rewrites config before startup, and makes a Go-based proxy engine feel native on macOS.

A close look at how `anomalyco/opencode-beta` acts as a release gateway, a cross-platform distribution layer, and a clue to the real shape of OpenCode.

How a native iOS client uses hardware-isolated microVMs and an S3-backed filesystem to make self-hosted AI coding agents feel local.

A privacy-first journaling app that keeps the stack small, the data local, and the experience surprisingly rich.

A deep dive into how LifterLMS uses Composer, background jobs, and ecosystem-aware integrations to make a large learning platform feel simple for site owners and manageable for its engineers.

A Go-based private server that preserves a dead mobile RPG by patching the client, replaying its network contract, and rewriting its asset pipeline with surgical precision.

A manifest-driven platform for CRM, HR, documents, spreadsheets, and contracts, built to stay modular, type-safe, and migratable from the systems it wants to replace.

How LibreChat’s admin console turns Zod schemas, role-based overrides, and server-rendered React into a safer way to manage an LLM stack.

A local-first data layer for Markdown notes, where query results are not just readable. They can write properties back into the file itself.

Moving beyond the canvas to a hardened, headless production runtime for agentic workflows.

A private Flask platform for couples, families, and friends that swaps surveillance for passkeys, local AI, and a design built to survive upgrades, migrations, and long-lived use.

A schema-driven TypeScript monorepo that normalizes AWS, Azure, and GCP into one local control surface, then lets the backend teach the frontend how to render the UI.

A tiny README, a six-hour automation loop, and a contribution snake turn GitHub into the front end for a zero-config proxy distribution system.

A look at how a pre-boot PHP hook, Redis-class memory stores, and flag-based rules turn WordPress page caching into a precise control system instead of a blunt purge machine.

A Redis-native caching layer that serves HTML fast, isolates multisite traffic, and clears only the parts of the site that actually changed.

How hyperscalers use a massive Go test suite to force the world's largest hardware vendors to speak exactly the same language.

A single Docker image packages the agent, browser stack, developer tools, and persistent state so your setup survives rebuilds, host changes, and permission drama.

A GitOps-driven Kubernetes stack where Talos, Cilium, ArgoCD, and SOPS replace the usual cloud services, and a folder change can become a live deployment.

A monorepo that turns WordPress into a private distribution system, intercepts update checks, and keeps premium plugins off WordPress.org’s radar.

Dify AgentBox turns a polyglot, browser-ready sandbox into a reproducible build graph, so the environment is assembled from source instead of improvised by hand.

A vanilla PHP project with a surprisingly sophisticated map stack, automated importers, and offline-aware design, built for people who want control over their travel history.

A self-hosted agent platform with constitutional rules, trust-based tools, shared memory, and delegated tasks for the household.

Ami's most revealing code is not the agent itself. It is the release pipeline that turns a desktop AI environment into a GitHub release, a checksum, and a Homebrew install.

A Cog wrapper turns FLUX.1 Kontext into a production API with compile warm-up, FP8 layers, and TaylorSeer caching that preserve the scene while changing the prompt.

A meta-repo that shows how NVIDIA is rethinking functions, tasks, autoscaling, and observability for GPU workloads that are too heavy for ordinary serverless systems.

Moving beyond the chat box to build autonomous, file-based identities that live on your hardware.

A reference implementation that turns Power BI embedding into a readable pipeline of identity, token generation, and browser handoff, with service principal support, cloud-aware config, and safer failure modes.

A deep dive into the integrity/coordinator split, the link graph behind discovery, and the accountability tradeoffs in an agent-centric bulletin board.

A Node.js server emulator that reverse-engineers login, lobby, room, and combat traffic for Metal Rage Online, one packet and one state transition at a time.

A Django and HTMX app that introspects running Podman containers, exports Kubernetes YAML, and extends the workflow into Quadlets and systemd day-2 operations.

A visual builder that translates container intent into Kubernetes YAML, Quadlets, and deployable Podman configurations without making users learn the whole stack first.

How a Python control plane creates a programmable digital twin to orchestrate raw NVMe hardware and resolve kernel-level split-brain.

Why a rising LLM power chose to mimic two giants at once to win over the Vercel ecosystem.

A tiny Flask app reveals the real shape of most AI tools: one browser shell, one server, two prompts, and a lot of leverage hiding in plain sight.

How a minimalist Flutter implementation solved the 'Heavy Blob' problem using Firebase as a reactive metadata index.

How a handful of Bash scripts orchestrate multi-GPU Vision-Language Models to bring air-gapped, state-of-the-art OCR to the enterprise.

A self-hosted F-Droid pipeline that turns release assets and GitHub Actions builds into a browsable Android repo, with no database, no build farm, and no manual packaging loop.

How a zero-config sidecar pattern and a custom search DSL are bringing production-grade observability to the local development environment.

How a foundational Flutter prototype decoupled the Employee experience from the Employer's gaze.

How the "GitLab for Databases" is collapsing the wall between application code and schema state through collaborative DevSecOps.

How a native Swift application wraps Astral's blazing-fast uv package manager, bringing Rust-powered Python tooling to the macOS desktop without the Electron bloat.

How a legacy Python 2.7 app on Google App Engine uses defensive data engineering and fan-out task queues to process global telemetry without a massive cloud bill.

A small TypeScript server, a Python generator, and a bigger idea: turning a personal cloud OS into an AI-native control surface.

A Django and React app that treats books like physical assets, shelves like permissioned spaces, and sync like the default instead of the exception.

How a Python-based expert system replaces thousands of lines of manual YAML editing with an interactive, version-aware deployment pipeline.