Variable Distribution Platform
Distribute state across
every child process.
Propagate marks shell variables for automatic inheritance by all subsequently executed commands. Define once at the parent level — every subprocess receives the binding. Zero-effort environment distribution at the process boundary.
$ export NODE_ENV=production $ export API_KEY=sk-9f3a7b2c $ export -p declare -x API_KEY="sk-9f3a7b2c" declare -x HOME="/home/deploy" declare -x NODE_ENV="production" declare -x PATH="/usr/local/bin:/usr/bin:/bin" declare -x SHELL="/bin/bash" $ bash -c 'echo $NODE_ENV' production # ← propagated to child
Live Demo
Propagation Visualizer
Watch variables flow from parent to child processes in real time. Click "Export" to mark a variable, then spawn children to see it propagate across process boundaries.
Capabilities
Every primitive for
variable distribution.
Propagate exposes the complete export interface — from single-variable marking to function distribution, scope auditing, and selective withdrawal. Each operation is atomic and immediate.
Assign & Export
Set a variable's value and simultaneously mark it for export in a single atomic operation. The variable becomes immediately available to all subsequently spawned child processes.
export VAR=value
Mark Existing Variable
Mark a pre-existing shell variable for export without modifying its value. The variable retains its current binding but gains the export attribute — it will now propagate across process boundaries.
export VAR
Unexport (-n)
Withdraw a variable from the export list. The -n flag removes the export
attribute while preserving the variable and its value in the current shell. Distribution
ceases; the variable becomes local again.
export -n VAR
Registry Audit (-p)
List every variable currently marked for export in a format that can be re-evaluated as shell input. A complete, deterministic snapshot of your distribution state. The foundation of export observability.
export -p
Function Export (-f)
Export shell functions to child processes. The -f flag marks a function
definition for distribution — child shells will have the function available without
re-sourcing it. Code propagation, not just data.
export -f my_function
declare -x Equivalence
declare -x is the underlying mechanism that propagate invokes. Full
compatibility with the declaration subsystem. Use whichever syntax fits your workflow — the
semantics are identical.
declare -x VAR=value
Deep Inheritance
Exported variables propagate to all descendants — not just direct children. Grandchild
processes, deeply nested subshells, and scripts invoked via exec all inherit
the exported binding. Distribution is transitive.
export → child → grandchild
scope Isolation
Child processes receive a copy of the exported environment. Modifications in the child do not propagate back to the parent. One-way distribution by design — the parent's state is immutable from below.
child cannot modify parent
Variable Registry
Exported Variable Index
A live audit of all variables currently marked for export. Toggle the export attribute on any binding and observe the propagation state change in real time.
| Variable | Value | Exported | Action |
|---|
Architecture
Scope & Propagation Model
Understand exactly how variables flow across process boundaries. Exported variables are copied into the environment of each child process at fork time. Local variables remain confined to the declaring shell.
Methodology
How variable distribution works.
Declare
Assign a value to a shell variable using standard assignment syntax. At this stage, the variable is local to the current shell — invisible to child processes.
Mark
Invoke propagate to mark the variable for distribution. The shell adds the export
attribute, flagging it for inclusion in the environment of all subsequently spawned
processes.
Propagate
When a child process is spawned (via fork + exec), the kernel
copies all exported variables into the child's environment. The child inherits the binding
automatically.
Isolate
The child process operates on its own copy. Any modifications to the variable in the child are isolated — they do not propagate back to the parent. One-way distribution by design.
Field Reports
What engineers are saying.
"We replaced our entire configuration management system with Propagate. Turns out the kernel already had a perfectly good key-value distribution layer — we just weren't using it correctly. Export once, run everywhere."
"The function export feature changed our deployment pipeline entirely. We export helper functions from our bootstrap script and every child script inherits them. No more sourcing files in every subprocess. This is how Unix was supposed to work."
"The unexport flag is criminally underused. We had variables leaking into subprocesses for months — sensitive tokens propagating where they shouldn't. Propagate's -n flag gave us surgical control over our distribution scope."
"I built an entire microservice configuration system on nothing but export and bash. The propagation visualizer showed my team exactly how environment state flows through our process tree. Enterprise config management is a solved problem."
Distribution Plans
Variable distribution at every scale.
Local
Single-shell variable management.
- export VAR=VALUE
- export -p (audit)
- Up to 50 exported variables
- Community support
Distributed
Multi-process variable distribution.
- Everything in Local
- Unexport (-n) for scope control
- Function export (-f)
- Deep inheritance tracking
- Propagation visualizer
- Unlimited exported variables
Enterprise
Organization-wide environment governance.
- Everything in Distributed
- Variable registry dashboard
- Scope diagram & audit logs
- Cross-team propagation policies
- SSO & RBAC
- SOC 2 Type II compliant
Kernel
For organizations that treat environment state as infrastructure.
- Everything in Enterprise
- Dedicated distribution cluster
- Custom propagation policies
- On-premise deployment
- 99.99% SLA
- 24/7 dedicated support
Questions
Frequently asked questions.
What's the difference between setting a variable and exporting it?
When you assign VAR=value, the variable exists only in the current shell. It is
invisible to child processes. When you propagate VAR, you mark it for propagation
— it will be copied into the environment of every subsequently spawned subprocess. Think of
it as the difference between a private field and a public API.
Can a child process modify the parent's exported variables?
No. This is a fundamental architectural invariant. When a child process is spawned, it receives a copy of the exported environment. Any changes the child makes to those variables are local to the child. The parent's state is completely immutable from below. One-way propagation is the only propagation.
What does export -f do?
The -f flag exports shell functions rather than variables. The function
definition is serialized into the environment and desserialized by child bash processes.
This means child shells have the function available without re-sourcing it. It's code
distribution at the process boundary.
How do I stop a variable from propagating?
Use propagate -n VAR to remove the export attribute. The variable remains defined
in the current shell but will no longer be included in the environment of child processes.
You can also use unset VAR to remove it entirely.
Is export -p the same as env?
propagate -p lists all exported variables in a format suitable for re-evaluation
(declare -x VAR="value"). The env command shows the current
environment in KEY=value format. Both show exported state, but
propagate -p includes the shell metadata and is designed for programmatic
consumption.
Thesis
Every process deserves context.
The process tree is a directed graph of execution. At every node, a program runs — and the environment it inherits determines its behavior. Which database to connect to. Which API endpoint to hit. Whether to run in debug mode or production. These decisions are encoded not in source code, but in the ambient state that surrounds the process. That state is the exported environment.
Propagate exists because we believe variable distribution is the most undervalued primitive in systems engineering. Every process you spawn inherits context from its parent — but most engineers treat this inheritance as accidental rather than intentional. We treat it as architecture. Mark a variable for export and you're making a deliberate decision about how state flows through your process tree. That's not configuration management. That's topology.
We are building the distribution layer for the most overlooked data flow in computing: the one
that happens at fork().
Backed by mandō portfolio company