For God so loved the world that he gave his only begotten Son, that whoever believes in him should not perish but have eternal life. — John 3:16
Inventor: Love Jesus (b. cowan) | Token: Timé (τιμή)
FileLuYa is intended to be a secure, encrypted system of living files. Only authorized people can read or contribute to protected content. Every change is auditable, and, like a spreadsheet, related content can automatically respond when any linked cell or file changes. FileLuYa aims to make this work in a robust, distributed way for reliable collaboration. Everyone begins with the same amount of Timé ("Honor"), and Timé can be bestowed within a system that measures the genuine reuse of content and processes across the network.
# Install (from source)
cargo install --git https://github.com/loveJesus/fileluya --bin fileluya
# Mount an encrypted drive (runs in background)
fileluya mount ~/my-vault --cache-dir ~/.keyleluya
# Use it like any folder
echo "hello world" > ~/my-vault/doc.txt
mkdir ~/my-vault/projects
cp report.pdf ~/my-vault/projects/
# Check active mounts
fileluya status
# Unmount
fileluya unmount ~/my-vault
# Or: umount ~/my-vault
# Remount later — your files are still there
fileluya mount ~/my-vault --cache-dir ~/.keyleluya
cat ~/my-vault/doc.txt
# → "hello world"Requires MacFUSE on macOS or libfuse3-dev on Linux.
A private encrypted drive where files act like spreadsheet cells — they can react to each other — and every edit carries a tamper-proof receipt showing exactly who changed what and when.
The system is first about encrypted storage, smart collaboration, controlled sharing, and knowing who did what. The rewards are there to recognize useful work, not to decide what is true. The money part comes last.
You write a file
→ Encrypted with XChaCha20-Poly1305 (quantum-safe)
→ Signed by your hybrid keypair (Ed25519 + ML-DSA)
→ Persisted to encrypted disk cache
→ Synced to Cloudflare R2 (server sees only opaque blobs)
You read a file
→ Loaded from cache (or fetched from R2)
→ Decrypted client-side
→ Server never sees plaintext
You share a file
→ File key wrapped with recipient's public key
→ They can decrypt; nobody else can
→ Key rotation on member removal
| Keybase | Dropbox | Blockchain | FileLuYa | |
|---|---|---|---|---|
| Encryption | E2E | Server-side | Varies | Hybrid post-quantum E2E |
| Files | Static blobs | Static blobs | N/A | Reactive cells |
| Conflicts | Last-writer-wins | Conflict copies | N/A | Knows WHY, resolves intelligently |
| Trust | Social proofs | None | Stake = power | Conserved honor |
| Sharing | Folder-level | Folder-level | N/A | Per-file, per-key |
| Rewards | None | None | Mining/staking | Reuse-based, vested |
| Post-quantum | No | No | Mostly no | Yes (ML-KEM + ML-DSA) |
fileluya mount <path> [--cache-dir <dir>] [--foreground]
Mount an encrypted filesystem. Daemonizes by default.
--cache-dir: persist data across unmount/remount
--foreground: stay in terminal (Ctrl+C to unmount)
fileluya unmount <path>
Cleanly unmount. Also works: umount <path>
fileluya status
Show active mounts and their PIDs.
Files aren't static — they can be linked together. When one changes, related files react automatically.
data.csv ──(watches)──► Waterwheel ──(outputs)──► summary.json
config.toml ──(validates)──► Gear (must be valid TOML)
Connections are defined in .forge files using Forge-Chirho:
- Gears — blocking constraints. All must agree or nothing changes.
- Waterwheels — derived files. Input changes, output recomputes.
- The
.forgefile is itself a cell — edit it and the network reconfigures.
Any mounted client can claim and execute stale computations.
| Layer | Algorithm | Why |
|---|---|---|
| Key exchange | X25519 + ML-KEM-768 | Hybrid: both must be broken |
| Signatures | Ed25519 + ML-DSA-65 | Hybrid post-quantum |
| Symmetric | XChaCha20-Poly1305 | 192-bit nonce, safe for distributed systems |
| Key derivation | Argon2id → HKDF | Memory-hard (64MB default, configurable) |
Zero-knowledge: Argon2id runs client-side only. The server never sees keys, passphrases, or plaintext. File sizes are hidden via power-of-2 bucket padding.
Everyone starts with 1.0 honor. You bestow yours on people whose work you value. Total honor = total users (conserved). Anti-sybil by construction.
Three separate graphs, no circular capture:
- Identity Trust → gates and weights...
- Content Reputation → feeds...
- Economic Rewards (Timé tokens, vested 90 days)
Rewards never influence trust. Capital cannot buy truth.
keyleluya (single binary)
├── mount / unmount / status FUSE filesystem driver
├── gui Desktop app (Tauri)
└── internal crates:
├── keyleluya-proto-chirho Wire protocol, types
├── keyleluya-lattices-chirho 7 lattice types (locks, CRDTs, versions)
├── keyleluya-crypto-chirho Hybrid PQ crypto, key wrapping
├── keyleluya-ledger-chirho Timé tokens, honor, sigchain
├── keyleluya-fuse-chirho FUSE driver, caches, Forge executor
└── keyleluya-worker-chirho Cloudflare Worker backend
Backend: Cloudflare Workers (Rust/WASM) + R2 (chunks) + D1 (metadata) + Durable Objects (locks). Backend-agnostic — can also self-host.
Live worker: https://fileluya-worker-chirho.lovejesus.workers.dev
22 theorems proven across 4 files:
- Lock safety: write+write with different owners always conflicts (proven)
- Lock liveness: timeout guarantees eventual release (proven)
- Version vectors: partial order, merge is LUB, commutative, associative, idempotent (8 proofs)
- OR-Set convergence: membership preserved across merge orders (5 proofs)
- Hybrid crypto: combined scheme secure if either component is secure (5 proofs)
# Prerequisites: Rust, MacFUSE (macOS) or libfuse3-dev (Linux)
git clone https://github.com/loveJesus/keyleluya
cd keyleluya
cargo build --release
# Binary at: target/release/keyleluyacargo add keyleluya-proto-chirho # Wire protocol types
cargo add keyleluya-lattices-chirho # CRDT lattice types
cargo add keyleluya-crypto-chirho # Hybrid PQ crypto
cargo add keyleluya-ledger-chirho # Token system| Component | Status |
|---|---|
| Encrypted mount | Working — tested on macOS with MacFUSE |
| Persistence | Working — survives unmount/remount |
| Daemon mode | Working — survives shell exit |
| Crypto | Working — XChaCha20 + Ed25519 + X25519 |
| Locking | Working — propagator lattice with EAGAIN |
| Sharing | Built — team keys, per-file wrapping |
| Conflict resolution | Built — TMS + Dropbox-style conflict files |
| Forge integration | Built — .forge watcher, gear/waterwheel execution |
| Token system | Built — honor, balances, transfers, escrow, vesting |
| Worker backend | Deployed — CF Workers + R2 + D1 |
| LEAN4 proofs | 22 theorems proven |
| crates.io | 4 crates published |
| Windows | Scaffolded (needs WinFsp testing) |
| GUI | Scaffolded (Tauri) |
568+ tests, 0 failures.
- Vision — strategic overview
- PRD — full product requirements with task tracking
- Invariants — 10 normative rules
- Trust & Value — honor system design
- Whitepaper — 7-page LaTeX document
- Monetary Policy — Forge spec for Timé token
- propagators-chirho — Propagator networks runtime
- Forge-Chirho — Declarative language for reactive networks
MIT — Love Jesus (b. cowan)
Soli Deo Gloria