JR® ← Mnestia

Mnestia Feature Index

400+ features · 24 categories · 200+ knowledge guides · Complete reference

Views & Navigation

Every workspace in one window. Switch between views with the sidebar.

  • Dashboard — Stats, quick actions, and recent notes on a single landing screen.
  • Notes — Read/Edit toggle with live markdown rendering, wikilinks, frontmatter, and auto-save.
  • Graph — Interactive force-directed graph of your entire vault. Drag, zoom, click to open.
  • Projects — Vaults, Sites, Apps, and Files in one place.
  • ACP (Agent Chat) — Multi-session agent chat with streaming, tool use, and image support.
  • Terminal — Integrated PowerShell/bash with agent launcher.
  • FTP — FTP/SFTP file browser and manager with saved server profiles.
  • API Keys — Secure credential storage, encrypted at rest, never in your vault files.
  • Settings — Accent color, font size, agent management, vault tools, specialize mode.
  • Mnestia AI — Fully offline local inference pane. No network, no telemetry.

Note Editing & Markdown

Plain markdown files with full editing power. Your notes are yours.

  • Read/Edit toggle — Switch between rendered view and raw editor without page reflow.
  • Live markdown rendering — Bold, italic, code, links, lists, tables, blockquotes, syntax-highlighted code blocks.
  • Wikilinks — [[Note Name]] linking with dead-link detection. Click to navigate.
  • Frontmatter support — YAML metadata (title, type, tags, updated) parsed and displayed.
  • Auto-save — Debounced saves (800ms) with a visual save-indicator dot.
  • Backlinks — See every note that links to the current one.
  • Note outline — Heading-based document outline for quick section jumping.
  • Recent notes — Dashboard tracks your most recently opened notes.
  • Create / Rename / Delete — Full file management within vault confinement.
  • Reveal in Explorer — Open the file's location in your system file manager.
  • Font size control — Adjustable editor font size for comfort.
  • Monospace editor — Code-friendly editing with a monospace font.

AI Agents (ACP)

Connect your own AI. Mnestia is the memory; the intelligence is your pick.

  • Multi-agent support — Claude Code, Gemini CLI, ChatGPT (Codex), Qwen Code, OpenCode (Ollama), or bring your own.
  • Multi-session chats — Multiple concurrent conversations over one agent process. Tab between them.
  • Real-time streaming — Token-by-token response streaming as the answer is written.
  • Tool use visualization — Live tool-call cards showing Read, Write, Edit, Bash, Grep, and more as they happen.
  • Thinking display — See the agent's reasoning stream in real time (toggleable).
  • Queue system — Queue messages while the agent is busy. They fire in order when it's ready.
  • Mid-turn steering — Send follow-up messages during an active turn to redirect the agent.
  • Session persistence — Chat transcripts auto-saved to Brain/Chats/ as markdown.
  • Activity panel — Collapsible per-turn tool activity log with file paths and diffs.
  • Turn metrics — Token usage, turn duration, and status tracking per turn.
  • Stop / Cancel — Interrupt any active turn immediately.
  • Image support — Paste or attach images directly in chat for multimodal prompts.
  • Retry failed turns — One-click retry on any failed turn.
  • Undo turn — Roll back all file writes from a turn with one click, with a pre-rollback snapshot.
  • Archive chats — Move completed conversations to an archive folder.
  • Browser OAuth sign-in — Automated login flow that opens a browser, authenticates, and returns the token.
  • One-click install — Agent CLI not installed? The app detects it and offers guided installation.
  • Connection status — Live indicator showing whether the agent is connected, busy, or idle.
  • Agent switching — Change agents mid-session without restarting the app.
  • Context window tracking — See what percentage of the agent's context window is used.
  • Auto-nudge — If the agent stalls during a build, Mnestia nudges it to keep going.

Agent Permissions & Safety

You control what the agent can do. Every action can be reviewed before it happens.

  • Three permission modes — Auto-approve (fast, trusts the agent), Accept edits only (auto-reads, approves writes), or Ask every time (full human-in-loop).
  • Tool approval popups — Every tool call can be individually approved or rejected before execution.
  • Diff previews — See exactly what the agent wants to change before you approve a write.
  • Per-turn checkpoints — Undo an entire turn's changes with a single click.
  • Session changes log — Per-session audit trail of every file the agent touched.
  • File write locks — Cross-session conflict prevention. One agent writes a file at a time.
  • Lock owner display — "Locked by Chat 2" messages so you know which session has the file.
  • Force write override — Human override when you need to break a stale lock.
  • Heartbeat cleanup — Stale locks auto-expire if the holding session crashes.
  • Vault scope vs System scope — Confine agent reads to the vault, or open the whole system. Writes always stay scoped.

Model Selection

Choose the AI model for each agent. Cloud or local, your pick.

  • Per-agent model picker — Choose which model each agent uses (Claude Sonnet, Opus, Haiku, etc.).
  • Ollama Cloud harness — Route to cloud models (GLM-5.2, Qwen3 Coder 480B, etc.) via Ollama Pro.
  • Harness picker — Switch between OpenCode, Claude Code, Codex, OpenClaw, Hermes, Qwen.
  • Model override — Inject environment variables like ANTHROPIC_MODEL for fine-grained control.

Local AI (Fully Offline)

On-device inference with zero internet. No data leaves your machine.

  • Fully offline inference — On-device LLM via node-llama-cpp + Qwen3 GGUF. Works with zero internet.
  • Speed modes — Slow (thorough), Balanced, or Fast (quick answers). Adjusts thread count and token cap.
  • Live CPU/RAM meter — Real-time resource usage visualization while the model runs.
  • RAG retrieval — Searches your vault for relevant excerpts and injects them as context.
  • Session reset — Clear context to start fresh.
  • Model unload — Free RAM manually when you're done with local AI.
  • GPU detection — Automatically detects Vulkan/Metal for GPU offloading when available.
  • Thread capping — Leaves OS headroom so your machine stays responsive.
  • Identity guard — System prompt prevents the model from misattributing itself.
  • Usage logging — Performance reports written to mnestia-usage.jsonl.

Graph Visualization

See the shape of your knowledge. Every note is a node, every link is an edge.

  • Force-directed layout — D3.js physics simulation. Nodes repel, links pull, and the shape reflects your vault's structure.
  • Node types — Hub (high-degree, large), Leaf (small), Folder, Orphan. Color-coded and sized by connection count.
  • Interactive — Drag nodes, zoom, pan. Click any node to open that note.
  • Accent theming — Graph colors match your app accent setting.
  • Collision detection — Nodes never overlap. The simulation handles spacing.
  • Orphan clustering — Unlinked notes group together so you can spot gaps.
  • Idle detection — Simulation stops when the graph settles to save CPU.
  • Animation pause — Graph pauses when the window is hidden or minimized.

Projects & Site Builder

Build real software from inside the app. Websites, desktop apps, games, audio tools.

  • Website projects — PHP, React, Ruby on Rails, Go. Pick a stack, the builder handles the rest.
  • Desktop app projects — Rust (Tauri), Electron, C++ (JUCE), Capacitor (mobile).
  • Game engine projects — C++ with Vulkan, bgfx, OpenGL, or D3D12 backends.
  • Specialized apps — Stem splitter, DAW, audio tools, media utilities, and more.
  • New project wizard — Guided flow: What, Kind, Stack, Style, Build.
  • Stack research — Agent verifies library compatibility before building.
  • Name verification — Checks your product name against trademark records before you commit.
  • 14 design presets — Dark SaaS, Aurora, Emerald, and more. Font picker, effect toggles.
  • Live preview — Built-in PHP dev server with auto-reload. See changes as the agent writes them.
  • Device emulation — iPhone viewport toggle for responsive testing.
  • Asset validation — Checks for 404 CSS/JS/images after every build step.
  • Error capture — PHP errors surface in a debugger panel, not hidden in logs.
  • Restyle mode — Change the visual style mid-build without starting over.

Code & Visual Editors

Read code, edit code, or drag-and-drop build pages visually.

  • Monaco Editor — VS Code's editor engine with syntax highlighting, multi-language support, and file tree.
  • Dirty tracking — Unsaved changes indicator so you never lose work.
  • Inspect element — Right-click any element in the preview to see its code in Monaco.
  • GrapesJS Visual Editor — Drag-and-drop WYSIWYG page builder with components, style manager, and code export.
  • Read-only by default — Preview mode protects files. The agent owns the writes, you own the approvals.

Versioning & Rollback

Every version saved. One click to go back.

  • Auto-snapshots — A snapshot is taken before every rollback so you can always undo an undo.
  • Manual snapshots — Label and save a version at any point during the build.
  • Version list — Browse all snapshots with timestamp, label, and auto/manual flag.
  • One-click rollback — Restore any previous version instantly.
  • Deduplication — Skips the snapshot if nothing changed.
  • 20-version rolling cap — Automatic cleanup keeps storage manageable.
  • Off-vault storage — Versions live in ~/.mnestia/versions/ so they don't clutter your vault.

Project Automation

Two-agent collaboration: one plans features, the other implements them.

  • Planner / Builder loop — Two-agent collaboration where one plans features and the other implements them.
  • Feature management — Add, remove, reorder features in your project's build queue.
  • Auto-flow handoff — Planner finishes, Builder automatically picks it up.
  • Shipped milestones — Track which features are completed and shipped.
  • Event log — Full build history showing who did what, when.
  • Token usage tracking — Estimated token usage per project build.
  • Comment system — Leave notes and instructions for the agents between runs.
  • Question tracking — Track unanswered questions so nothing gets lost.

Vault & Workspace

One brain, many projects. Each vault is a folder on disk that you own.

  • Unlimited vaults — Add as many vaults as you want. Each is a folder on disk.
  • Vault picker — Bottom-left switcher with vault cards showing name, path, and note/app/site counts.
  • Multi-vault mode — Select multiple vaults so the agent reads from all of them simultaneously.
  • Specialize mode — One vault at a time for focused work (toggle in Settings).
  • Workspace config — Each vault carries a .mnestia.json describing its notes folder, apps, and sites.
  • Brain view — Markdown files grouped by folder (the brain perspective).
  • File view — Recursive file tree showing all file types (the code perspective).
  • Vault repair — Restore missing essential brain files with one click.
  • Reveal vault — Open the vault folder in your system file manager.

FTP / SFTP

Deploy files to your host and manage remote servers from inside the app.

  • Server profiles — Save multiple FTP/SFTP sites with host, port, user, and protocol.
  • Encrypted credentials — Passwords stored with Windows DPAPI. Never plaintext.
  • Directory browser — Navigate remote folders with breadcrumb navigation.
  • File actions — Download, Upload, Delete, Rename from within the app.
  • Folder creation — Create new directories on the remote server.
  • File preview — View text files from the server without downloading.
  • Transfer progress — Upload/download status indicators.
  • Test connection — Verify credentials before saving a profile.

Terminal

A real shell inside the app. Not a chat widget, not a sandbox.

  • Multiple sessions — Tab-based terminals, as many as you need.
  • PowerShell / bash — Native shell, not a sandbox or emulation.
  • Agent launcher menu — Pick which AI agent to launch when you open a new terminal tab.
  • Boot animation — "Waking" agent with binary rain and ASCII art (toggleable).
  • Fuzzy agent resolution — Type "gpt" and it finds ChatGPT. Typo-tolerant matching.
  • Shell-only option — Plain terminal, no agent, for when you just need a shell.
  • xterm.js — Full terminal emulator with resize handling and proper escape sequence support.

Security

Every security feature ships active out of the box. No toggles to find, no settings to enable.

  • Vault confinement — Agent writes are always confined to the project folder + selected vaults. Reads default to vault-only (expandable to system if you choose).
  • Path validation — safePath() and safeWrite() guards reject any path outside the allowed scope.
  • Credential encryption — All secrets (API keys, FTP passwords, auth tokens) encrypted with Windows DPAPI. Never stored in vault files.
  • No external network — Local AI runs entirely on-device. No telemetry, no phone-home, no cloud dependency for core features.
  • Cross-session file locks — Lock registry prevents two agent sessions from writing the same file simultaneously.
  • Heartbeat lock cleanup — If a session crashes, its locks auto-expire instead of deadlocking your vault.
  • Three permission modes — Choose your trust level: auto-approve, accept edits only, or ask every time.
  • Diff previews before writes — See exactly what changes before approving any file modification.
  • Per-turn undo — Roll back every write from an entire agent turn. Pre-rollback snapshot taken automatically.
  • Audit trail — Per-session log of every file touched, with before/after tracking.
  • Secrets isolation — Credentials stored in userData, never in synced vault files. Your brain can sync to the cloud without leaking keys.
  • Destructive command guards — Safety hooks block dangerous shell commands before they execute.

Onboarding & Setup

Guided setup from first launch to first build. No manual configuration needed.

  • Full-window setup wizard — 8-step guided onboarding: boot splash, prerequisites, profile, agent connection, first build, and more.
  • Prerequisite detection — Auto-detects Node, npm, Git, PHP, Chrome, Obsidian, gh, rg, Playwright, and language toolchains (Rust, Go, Ruby, C++).
  • One-click installs — WinGet integration for Windows packages, npm global installs for agent CLIs.
  • Agent CLI detection — Checks for codex, claude, gemini, qwen and installs what's missing.
  • User profile — Name, role, how you like to work. Personalized into the brain's configuration.
  • First project build — Build your first site with live previews during onboarding, not after.
  • Style wizard — 14 design presets, font picker, effect toggles, custom description. Applied live.
  • Rerun anytime — Settings → Reset onboarding. Start fresh whenever you want.

Diagnostics & Debugging

When something breaks, these tools tell you exactly what happened.

  • Turn diagnostics — Live JSON report at ~/.mnestia/acp-turn.json tracking every tool call, status, and timing.
  • Hung turn detection — 2.5-minute silence triggers an automatic "hung" warning with process tree snapshot.
  • Preview diagnostics — Full JSON report of PHP path resolution, spawn errors, HTTP status, and startup sequence.
  • PHP error capture — Auto-injected error handlers surface errors in a debugger panel, not hidden logs.
  • Crash reports — JSON crash dumps saved to userData/crash-reports/.
  • Screenshot mode — --screenshot, --shot-acp, --shot-settings flags for automated diagnostics.

Performance

Fast by default. Resources used only when needed.

  • Lazy loading — File trees expand on demand. Monaco and GrapesJS load only when needed. Graph data is cached.
  • Render throttling — Markdown rendering debounced at 90ms during streams. Saves at 800ms after edits.
  • Resource management — AI model unload frees RAM. Graph animation pauses when hidden. Background throttling disabled to keep agent timers alive.
  • Process cleanup — All spawned processes killed on app exit. No orphan agents.
  • Incremental indexing — Brain search only re-embeds changed files, not the whole vault.
  • File size filtering — Files over 400KB are skipped during repo map to avoid token waste.

Accessibility

Built so everyone can use it.

  • Keyboard navigation — Tab order, focus management, keyboard shortcuts (Ctrl+P, Ctrl+S, Esc).
  • ARIA labels — Screen reader support with proper landmarks and aria-hidden for decorative elements.
  • Motion respect — prefers-reduced-motion disables all animations and transitions.
  • High contrast — Color scheme meets WCAG AA contrast requirements.
  • Focus indicators — Visible focus states on every interactive element.

What You Can Build

Not hypotheticals. These are real project types the builder supports, with architecture guides and code companions included.

  • Websites & SaaS — Landing pages, booking platforms, multi-tenant SaaS, e-commerce stores, job boards, newsletter platforms, membership communities, online course platforms.
  • Desktop apps — Audio tools, stem splitters, DAWs, video editors, brain/notes apps, product launchers, appraisal tools.
  • Communication tools — Click-to-call dialers, live video-call rooms, help desk / inbox, task boards, AI chat widgets, messaging platforms.
  • AI-powered tools — AI social-post generators, AI knowledge bases, content engines, usage-metered APIs.
  • Realtime apps — Live kanban boards, auction platforms, event ticketing, telehealth consults, collaborative editors.
  • Game engines — C++ engines with OpenGL/Vulkan/bgfx renderers, ImGui editors, entity systems, physics, skeletal animation.

Build Modules

18 full architecture guides with code companions. Each covers the real gotchas, multiple stack options (PHP / Node / Python), and a ready-to-use build prompt for your AI agent.

  • Auth & Accounts — Signed sessions, email-code 2FA, brute-force throttling, CSRF protection, multi-tenant data scoping, server-side RBAC.
  • Payments — Stripe Checkout + Connect for marketplace payouts. Idempotent, signature-verified webhooks.
  • Scheduling & Calendar — Availability windows, recurring bookings expanded on read, cancellations, reschedule requests, reminder cron jobs.
  • Video Calls — Embedded video rooms with RS256 JWT minting, moderator vs participant roles, presence tracking, reconnect-grace state machine.
  • Telephony & Dialer — In-browser dialer for inbound/outbound PSTN calls, voicemail + transcription, call inbox routing.
  • Realtime State Sync — Broadcaster-to-subscriber relay, sequence-numbered events, bounded history window, heartbeat presence detection.
  • AI Content Engine — Web scanner to knowledge base to skills/assets library. Templated LLM generation with provider failover.
  • No-Framework SPA Core — Hash router + central store + CSRF-aware fetch wrapper. Zero build step, zero dependencies.
  • Messaging & Notifications — In-app message threads, read/unread tracking, invites, and an unread-count notification system.
  • File Uploads — Scoped uploads with extension/MIME whitelist, size caps, per-tenant storage quotas, garbage collection, presigned URL serving.
  • Admin, Audit & Activity — Admin console backend, append-only audit log, and a sanitized tenant-scoped activity feed.
  • Support Tickets — Ticket system with AES-256-GCM encrypted messages at rest, statuses, admin replies, email notifications on create.
  • Rate Limiting & Quotas — Per-plan rate limits + usage/storage quotas with clean 429 and quota-exceeded responses.
  • Search & Filtering — Client-instant filter, server query + facets + sort + pagination, and when to graduate to a real search engine.
  • Backups & Recovery — Layered offsite backups (data daily, full weekly, manual image), hardened scripts that fail loudly, verify-at-destination.
  • Error Monitoring — Capture JS + server errors, fingerprint/dedupe into issues, rate-limited alerts. DIY or Sentry integration.
  • Email & Deliverability — Three sending lanes (transactional, marketing, cold), SPF/DKIM/DMARC, Gmail receiving, reputation isolation.
  • Computer Vision — OpenCV DNN-based object detection (YOLO/SSD via ONNX), classical CV, video capture pipelines, tracking, image processing, 3D/AR.

Knowledge Base

200+ hard-won lessons, patterns, and gotchas extracted from real production builds. Every note ships with the app so your AI agent already knows these things when it starts building.

Security & Auth

  • CSRF on Every Write — Why every state-changing request needs a token, and how to wire it.
  • Signed Session Auth — Server-side session signing so tokens can't be forged.
  • Hash Passwords — Why bcrypt/argon2 is non-negotiable and how plaintext kills you.
  • RBAC Server-Side — Role-based access control enforced on the backend, not the UI.
  • OAuth & OIDC Third-Party Login — Wiring Google/GitHub/Apple sign-in without leaking tokens.
  • Security Headers — CSP, HSTS, X-Frame-Options, and every header your site needs.
  • Security Layers for Your First Site — Minimum viable security for a real launch.
  • SSRF Guard on Outbound Fetch — Blocking server-side request forgery before it starts.
  • Secrets in Env, Not Code — Why API keys belong in environment variables, not source files.
  • Command Injection via Folder Names — How a bad folder name can execute shell commands.
  • FTPS, Not Plain FTP — Why unencrypted FTP leaks your credentials in transit.
  • DPAPI Credential Extraction — Securely decrypting stored credentials for automated deploys.
  • Guard Destructive Commands — Safety hooks that block dangerous shell operations before they run.
  • Anti-Piracy Layers — License keys, hardware fingerprinting, and tamper detection for desktop apps.
  • License Keys via Asymmetric Cryptography — Offline-verifiable license keys using RSA/Ed25519.
  • Fingerprint, Dedupe & Rate-Limit Alerts — Preventing alert floods without missing real incidents.
  • Consumer OAuth Tokens — Why user-facing OAuth tokens aren't safe for third-party app auth.
  • Vault Path Confinement for Terminal — Keeping shell commands scoped to the project folder.
  • Preventing Bypass Attacks — Closing the gaps attackers use to skip your validation.

Web & Frontend

  • No-Framework SPA — Building a single-page app with hash routing and no build step.
  • CSS Scaling in Embedded Webviews — Making web content render correctly inside desktop app frames.
  • CSS Cursor-Driven Animation — Mouse-follow effects without JavaScript overhead.
  • CSS Animation Freeze for Export — Pausing animations to capture clean screenshots or video frames.
  • Blueprint CSS Override Specificity — Overriding framework styles without !important wars.
  • Overflow Hidden Kills Descendant Scroll — Why a parent's overflow:hidden silently breaks child scrolling.
  • Scrollable Areas Need a Constrained Height — The CSS box model rule that trips up every scroll container.
  • Transform-Based Horizontal Scroll — Smooth horizontal scroll panels using CSS transforms instead of native scroll.
  • Persist UI State Across Page Loads — Saving collapsed panels, scroll positions, and selections to localStorage.
  • Lift State Above Unmounting Components — Moving state up so it survives component lifecycle in React/frameworks.
  • Blob URL Lifecycle — Why blob: URLs leak memory if you don't revoke them.
  • SVG foreignObject Rendering — Embedding HTML inside SVG for mixed-mode graphics.
  • Empty Overlay Intercepts Clicks — An invisible div blocking all interaction underneath it.
  • Iframe Preview Cache Fix — Forcing iframe content to reload instead of showing stale cache.
  • React Landing on Shared Hosting — Deploying a React SPA to cPanel without Node on the server.
  • Vite Multi-Page Build — Configuring Vite for multiple HTML entry points instead of SPA-only.
  • DPI Scaling in Native Apps — Handling high-DPI displays so your UI isn't blurry or tiny.

AI & Agent Patterns

  • Building AI Systems — Architecture patterns for shipping AI-powered products.
  • Give Small Models Room to Think — Why smaller LLMs need explicit reasoning steps to perform.
  • Prompt Caching & Token Economy — Reducing API costs by caching shared prompt prefixes.
  • Provider Failover — Automatically switching AI providers when one goes down.
  • OpenAI-Compatible API — Using the OpenAI API format with any compatible model provider.
  • AI Is a Partner, Not an Author — Why the human decides and the AI drafts — not the reverse.
  • AI Detection Blocks Boot — When antivirus flags your AI model files on first launch.
  • Evaluation Matrix for AI Output — Structured scoring to judge whether AI-generated content is good enough.
  • Token Counting Must Include Tool Results — Why context window math breaks if you only count prompts.
  • System Reminder Tags for Context Injection — Injecting live context into agent conversations without user action.
  • Brain Digest: One-Breath Session Loading — Summarizing the entire knowledge base into a single startup read.
  • Model Override Per Process — Running different AI models per agent session via environment variables.
  • Coordinate Parallel Agents — Shared registry pattern so multiple agents don't conflict on the same files.
  • ACP Steer Race Condition — Preventing mid-turn steering messages from corrupting agent state.
  • Notify & Approve Agent Remotely — Reviewing and approving agent actions from your phone.
  • Queue Bubbles in Chat Body — Showing queued messages inline so the user sees what's pending.
  • Stop Button Must Preserve Streamed Content — Canceling a turn without losing the partial response.
  • Build a Live Debug Log for AI — Real-time diagnostic logging so agents can troubleshoot their own work.
  • CLI Over MCP — Why a direct CLI connection beats a Model Context Protocol wrapper for local agents.
  • Slash Command as Codified Workflow — Turning repeatable tasks into one-word agent commands.
  • Standalone ACP Client in Tauri — Embedding an agent communication protocol client in a Rust desktop app.

Desktop App Development

  • Shipping & First Install — Per-OS installers, bundling runtimes, first-run wizards, code signing, clean-machine testing.
  • Building a Visual Website Editor — Architecture for a drag-and-drop page builder inside a desktop app.
  • Embedding a Live Web Preview — Rendering live website previews inside your app's webview.
  • Tauri Async Command Requires Result — Why every Tauri IPC command must return a Result type.
  • withGlobalTauri in Plain JS — Accessing Tauri APIs from vanilla JavaScript without a bundler.
  • WebView2 Cache Stale JS — When Microsoft's WebView2 caches old JavaScript and ignores your updates.
  • Electron Overlay Notification — Non-blocking toast notifications in Electron apps.
  • Sidecar Process Lifecycle — Launching, monitoring, and cleaning up child processes in desktop apps.
  • Desktop Shortcut Points to Stale Binary — When your shortcut points to an old build after a rebuild.
  • Kill Running EXE Before Rebuild — Preventing "file in use" errors during development builds.
  • Signal-Based Crash Handler — Catching segfaults and writing crash dumps before the process dies.
  • Settings File Rogue Agent Wipe — When an AI agent accidentally overwrites your entire config file.
  • Assume the Clean Machine — Testing your installer on a fresh OS with nothing pre-installed.
  • Mutex Guard Across Await — Why holding a lock across an async boundary causes deadlocks in Rust.

Audio & Music Technology

  • JUCE WebView Hybrid Architecture — Building audio apps with a C++ backend and web-based UI.
  • JUCE WebView Linux WebKit Gotchas — Platform-specific issues when shipping JUCE web UIs on Linux.
  • JUCE Parameter ID vs getName — The subtle difference between parameter IDs and names that breaks XML state.
  • JUCE DSP Tremolo Does Not Exist — Why the expected JUCE tremolo class isn't there and how to build your own.
  • Song Parts as Parallel Vectors — Data structure for representing verse/chorus/bridge arrangements in code.
  • Per-Scene Parameter Variations — Storing different effect settings per scene/patch in a live performance app.
  • Cluster Toolbar UI Layout — Organizing complex audio controls into a discoverable interface.
  • PipeWire Audio/Video Server — Replacing PulseAudio/JACK with PipeWire for lower latency on Linux.
  • DIY Pedalboard Hardware Build — Pi 5 + HiFiBerry DAC + custom case for a real guitar pedalboard.

3D Graphics & Game Engine

  • AABB Collision Resolution — Axis-aligned bounding box detection and response for game physics.
  • Half-Edge Mesh Editor Architecture — Data structure for editing 3D meshes with proper adjacency tracking.
  • OBJ Mesh Import Pipeline — Loading .obj files with vertex positions, normals, UVs, and materials.
  • OpenGL Depth-Only FBO — Framebuffer objects for shadow mapping and depth pre-passes.
  • Vulkan Negative Viewport Y-Flip — Correcting Vulkan's inverted Y-axis compared to OpenGL.
  • Vulkan UBO Single Overwrite — Updating uniform buffer objects without double-buffering issues.
  • View Matrix Translation — Why the camera's view matrix translation isn't the camera position.
  • Double Model Matrix Shader Bug — When the model matrix gets applied twice and everything renders wrong.
  • First-Person Arms in Camera Space — Rendering FPS weapon arms in a separate coordinate space.
  • Cross Product Order for LookAt — Getting the right-hand vs left-hand cross product order correct.
  • std140 Alignment Padding — The GPU memory layout rules that silently corrupt your shader uniforms.
  • glTexSubImage2D Cannot Resize — Why sub-image updates fail when the texture dimensions change.
  • ImGui Docking Branch — Using Dear ImGui's docking branch for multi-window editor layouts.
  • ImGui GL Loader Missing Functions — Fixing OpenGL function pointer loading when ImGui can't find them.
  • ImGui Mode Bar Pattern — Building a toolbar that switches between editor modes.
  • Pathfinding & Viewport Overlay — Rendering A* pathfinding debug info as a viewport overlay.
  • Narrative Flags & Conditions — A flag-based branching system for game dialogue and story progression.

Video & Media

  • FFmpeg Video Encoding Patterns — Correct CRF, codec, and container settings for web-ready video.
  • Video Export from HTML/CSS — Capturing animated web content as video frames for export.
  • Bake Static Assets — Pre-rendering assets at build time instead of computing them on every request.
  • Anchoring HTML Overlays on a Rendered Document — Positioning floating UI elements over a document canvas.

Computer Vision

  • OpenCV Core — Full atlas of OpenCV capabilities from detection to deployment.
  • Image Processing — Filtering, thresholding, morphology, and color space operations.
  • Feature Matching & Stitching — Detecting keypoints and stitching panoramas from overlapping images.
  • Video & Motion Analysis — Optical flow, background subtraction, object tracking across frames.
  • DNN Detection & Text/Code Scanning — Neural network inference for objects, faces, text, and QR codes.
  • Face ID & Biometrics — Face detection, recognition, and identity verification pipelines.
  • 3D Calibration & AR — Camera calibration, pose estimation, and augmented reality overlays.
  • ML Shape Search — Contour matching, template matching, and learned feature search.
  • Deployment & Acceleration — GPU offload, ONNX Runtime, quantization, and edge deployment.
  • Specialized Contrib Modules — opencv_contrib extras: tracking, super-resolution, text detection, 3D.

Infrastructure & DevOps

  • Deploy One File, Reversible — Ship a single file with automatic backup and instant rollback.
  • Point Domain with DNS — Connecting your domain name to your server with A/CNAME records.
  • Match Host to Your Backend Language — Picking the right hosting for PHP vs Node vs Python.
  • One Host vs Many Hosts — When to consolidate services vs split them across servers.
  • Right-Size Your Infrastructure — Not over-provisioning servers for traffic you don't have yet.
  • Multi-Tenant Scoping — Isolating customer data so one tenant can never see another's.
  • Polling vs WebSockets — When simple polling beats the complexity of persistent socket connections.
  • Retry, Backoff & Circuit Breaker — Handling transient failures without hammering the failing service.
  • Idempotent Webhooks — Processing webhook events exactly once, even when they're delivered twice.
  • Webhook: Record After Side Effect — Why you log the webhook after the action, not before.
  • Webhook: GET or POST — Why most webhooks should be POST even when the provider sends GET.
  • Sequence-Numbered Events — Ordering distributed events so nothing is processed out of sequence.
  • Heartbeat Presence — Detecting whether a user or service is still alive with periodic pings.
  • Detect Silent Backup Failure — Catching when your backup job completes but didn't actually back anything up.
  • Know Your RTO/RPO — Recovery Time and Recovery Point Objectives — how much downtime and data loss you can tolerate.
  • Production Readiness Checklist — Everything to verify before your first real launch.
  • Test vs Live Environments — Keeping development and production separated from day one.
  • Recursive Listing Token Waste — Why scanning huge directory trees burns AI context for no benefit.
  • Automation SID Persistence — Keeping Windows service identities stable across reboots.

Linux & System

  • Custom Bootable ISO — Building a custom Arch Linux ISO with archiso for appliance deployments.
  • Arch Linux Audio Appliance Stack — A minimal Linux build optimized for real-time audio processing.
  • Desktop Customization (Ricing) — Theming Linux desktops with window managers, bars, and color schemes.
  • KDE Plasma Desktop — Configuring KDE Plasma for development and creative work.
  • Garuda Linux — An Arch-based distro with gaming/performance optimizations pre-configured.
  • Hyprland Wayland Compositor — Tiling window manager for Wayland with animations and workspace rules.
  • Openbox Window Manager — Lightweight X11 stacking window manager for minimal setups.
  • Plymouth Boot Splash — Custom boot animations that display while Linux is starting up.
  • SDDM Display Manager — Login screen manager with theming support for Linux.
  • Kvantum Theme Engine — SVG-based Qt widget theming for consistent desktop appearance.
  • Catppuccin Color Scheme — A pastel color palette family for terminals, editors, and desktops.
  • Cage: Minimal Wayland Kiosk — Running a single full-screen app in a locked-down Wayland session.
  • labwc Wayland Compositor — An openbox-like stacking compositor for Wayland.
  • SteamOS Dual-Mode Session — Switching between gaming mode and desktop mode on a Steam Deck.
  • Wayland vs X11 — When to choose Wayland over X11 and what breaks when you do.
  • Linux Zen Kernel — A kernel variant tuned for desktop responsiveness and low latency.
  • PipeWire Audio/Video — Replacing PulseAudio and JACK with a single unified media server.
  • systemd Rate Limiting — Why systemd stops restarting your service after too many crashes.
  • Pacstrap Double-Mount Corruption — A dangerous mistake during Arch installs that corrupts the target.
  • YAY AUR Helper — Installing packages from the Arch User Repository with automatic builds.
  • VM OOM During Compilation — Running out of memory when compiling inside a virtual machine.
  • VMware Workstation Provisioning — Setting up development VMs with proper resource allocation.

Business, Legal & Launch

  • Clear the Name Before You Brand — Checking trademarks, domains, and social handles before committing to a product name.
  • Name & Rebrand Due Diligence — The full sweep of code, DNS, certs, and legal pages a rename touches.
  • Rebrand a Live Site Safely — Executing a name change on a running production site without breaking everything.
  • Launch Legal Checklist — Terms, privacy policy, DMCA, accessibility, and compliance for day one.
  • US Law Map for Small SaaS — Federal and state rules that apply to a solo-dev subscription product.
  • Transactional vs Marketing vs Cold Email — The three email lanes and why mixing them kills deliverability.
  • Marketing: Discovery Intake First — Understanding the customer before writing a single word of copy.
  • Landing Page False Claims — What happens when your landing page promises features that don't exist yet.
  • Verify a Claim Against the Source — Fact-checking marketing claims before publishing them.
  • PUA Bundler Installers — Why bundled installer wrappers get flagged as potentially unwanted apps.
  • Audit Third-Party Code Before Install — Reviewing dependencies before adding them to your project.

Development Practices

  • Verify Before Done — Test and observe the real result before reporting a task as complete.
  • Check Source of Truth — Reading the actual data store instead of relying on a cached or derived view.
  • Research Stack Compatibility First — Verifying that your chosen libraries work together before writing any code.
  • Pin Your Stack — Locking dependency versions so a surprise update doesn't break your build.
  • Read the Config File First — Checking existing configuration before adding duplicate or conflicting settings.
  • Update Check Before Debugging — Ruling out a stale dependency before diving into a complex debugging session.
  • JSON Flat-File Store — When a simple JSON file beats a database for small-scale persistence.
  • Project Folder Discovery by Markers — Finding project roots by looking for package.json, Cargo.toml, etc.
  • 7-Zip Over Compress-Archive — Why 7-Zip beats PowerShell's built-in zip for large archives.
  • CRLF Breaks Edit Tool — Windows line endings silently breaking Unix-expecting text processing.
  • Chat Archiving Pattern — Moving completed conversations to an archive without losing history.
  • Graceful Degradation Over Hard Failure — Showing a fallback instead of crashing when a feature is unavailable.
  • Undeclared Variable Kills Features — When a missing variable silently disables functionality.
  • Undefined Function Reference Crash — Calling a function that doesn't exist yet and getting a blank screen.
  • Build vs Buy: Capture Is Easy — When it's simpler to build the capture layer yourself than adopt a vendor.
  • Mount Cloud Drive, Not API Connector — Accessing cloud storage as a local folder instead of writing API code.
  • Accessibility Is Table Stakes — Why a11y isn't a nice-to-have — it's a baseline requirement.
  • Design Gate: Read Before Building UI — Mandatory design skill review before writing any visual code.
  • Hard-Won Development Knowledge — The full collection of lessons that cost real time and real mistakes.
  • Instrument New Modules with a Diagnostic Report — Adding built-in health checks to every new feature.
  • One Brain, Many Projects — Using a single knowledge vault across multiple projects without conflicts.
  • Give AI a Deploy Tool — Letting the agent deploy via a script instead of giving it raw FTP credentials.
GET THE APP >> BACK TO OVERVIEW >>