Membrane logo

Membrane

Schema-optional, file-based project memory

Store things you’re working on as plain files.
Add whatever details matter. Change them later.
No setup. No rules. No lock-in.

Structure vs Emergence

Traditional systems require fixed fields, filling gaps with NULL.
Membrane lets objects define themselves; you retrieve what exists, and nothing else.

See Membrane in action — creating projects, setting keys, and switching workspaces in seconds.

Try It Out

Use this prompt with any AI tool to generate a project entry. Membrane doesn’t care about structure; it just remembers what you give it.

Prompt for Any AI

Generate a project entry for <your_project_or_idea>. Choose whatever keys feel most meaningful. Include the "name" key. Output only key:value pairs in valid YAML code block.

Example Output

name: Machine Learning Pipeline
status: in-progress
type: data-science
description: Building an ML pipeline for customer churn prediction
team: data-science
timeline: Q1 2026
technologies:
  - Python
  - TensorFlow
  - PostgreSQL
priority: high
last_reviewed: 2026-01-30

✨ No schema required. Your AI decides the structure. Membrane remembers it all.

Then use me push or paste it directly:

Copy the YAML output from your AI, run me push, and paste it into your terminal.

Built on Core Principles

Membrane strikes a balance between structure and freedom

📝

Projects as Files

Each project is a human-readable YAML file. No databases, no hidden metadata—just transparent data.

🔑

Keys are First-Class

Add, rename, delete, and inspect keys across projects. Your metadata lives where you decide.

🧬

Schema-Less by Design

No required fields. No rigid structure. Projects can contain any keys you define.

🌍

Workspace-Based

Create isolated branes and switch between them globally. Perfect for managing multiple projects.

Lightweight & Fast

Built in Rust with CLI-first design. Operates smoothly from anywhere on your system.

📊

Plain Files, Long Memory

Your data lives as files on disk. It doesn’t disappear when tools change.

Simple, Powerful CLI

Everything you need, nothing you don't. The me command does it all.

Initialize

$ me init

Create a new Membrane workspace in .membrane/

List Workspaces

$ me brane

View all known branes with active status

Switch Workspace

$ me checkout <id-prefix>

Switch to a different workspace globally

Create Project

$ me add my-project

Create a new project file with metadata

List Projects

$ me show

Display all projects in active workspace

Set Key

$ me set my-project status "in-progress"

Add or update a key-value pair

Install Membrane via Cargo:

cargo install membrane-cli

Then use me from anywhere

Distributed Memory Architecture

Membrane maintains a global registry of workspaces. Each brane sits independently, yet all can be accessed and switched between seamlessly.

Global Registry

Each workspace registers itself globally and can be accessed from anywhere on your system.

Explicit Switching

Commands operate on the active workspace. Switch between branes withme checkout

Stable Identity

Projects get unique IDs, allowing them to be referenced by name or ID prefix, regardless of location.

What it’s for

Designed for creative practitioners who need memory, not management

What Membrane is NOT

Not a task manager— It doesn't track deadlines or enforce workflows.

Not a calendar— Time-based tracking lives elsewhere.

Not a ticketing system— Issues and workflow state aren't its concern.

Not cloud-synced— Your data stays local and inspectable.

What it IS

A semantic layer— Sits above your tools, observing how language emerges in your work.

A durable memory— Projects and keys persist across time. You can reason about them.

Intentionally minimal— Doesn't automate decisions or enforce structure.

Yours to reason about— Inspectable, human-readable YAML files you control.

The Balance

Most project tools fail in one of two ways: they're either too rigid (fixed fields, schemas, workflows) or too vague (notes with no structure). Membrane finds the middle ground.

Projects are files. Keys are language artifacts. Structure is allowed to emerge organically. Metadata exists, but stays out of the way.

You decide what matters. Membrane just remembers it.