The declarative payment engine for the on-chain economy.
Define it in YAML. Execute it on Stellar.
NOIRE is a YAML-native workflow automation engine built on the Stellar blockchain. It lets developers, founders, and builders define complex financial logic in plain, human-readable YAML — and execute it on-chain without writing a single smart contract for the simple stuff.
Think of it as the automation backbone your Web3 product was missing. No boilerplate. No ceremony. Just intent → execution.
NOIRE is purpose-built on Stellar because the chain was purpose-built for payments:
- ⚡ Fast — 3–5 second finality, not minutes
- 💸 Cheap — fractions of a cent per transaction
- 🌍 Global — designed for cross-border, real-world payment flows
- 🦀 Smart — Soroban brings expressive Rust contracts to the ecosystem
Automation in Web3 is still unnecessarily brutal.
Want to send daily rewards to your community? Write a contract.
Want to trigger a payout when a condition is met? Write a contract.
Want to run subscription payments across wallets? Write a contract.
Even tasks that could fit on a napkin demand full contract deployments, audits, and gas optimization rituals. Non-engineers are locked out. Logic is fragmented across bespoke scripts. Nothing is auditable at a glance.
NOIRE changes this.
A declarative automation layer that sits between your application and the Stellar network.
You write the logic. NOIRE handles the rest.
# workflow.noire.yaml — your entire payment logic
workflow:
# reward new users automatically
- event: user_signup
action: send_xlm
amount: 5
to: user_wallet
# sustain the community treasury, daily
- event: daily
action: send_xlm
amount: 1
to: community_pool
# trigger conditional sweeps
- condition: balance > 100
action: send_xlm
amount: 10
to: treasury_walletThat's it. NOIRE validates it, anchors a hash on Stellar, and executes it — transparently and verifiably.
| What you'll work on | Why it matters |
|---|---|
| A real YAML execution engine | Parsing intent into on-chain action is a genuinely hard, interesting problem |
| Stellar + Soroban integration | Rust smart contracts on one of Web3's most underrated chains |
| Event-driven runtime in Go | High-throughput scheduling and webhook processing |
| A React dashboard | Real-time workflow editing with live execution logs |
| Developer SDK | Making this accessible to the next builder |
This isn't a toy project. The infrastructure pattern here — declarative logic over an execution engine — is the same architecture that powers Zapier, GitHub Actions, and AWS Step Functions. We're bringing it to Web3, on a chain built for global payments.
Define events, conditions, and scheduled triggers in plain YAML. Human-readable. Version-controllable. Reviewable by anyone on the team — not just engineers.
Trigger actions from user activity, API webhooks, or time-based schedules. No polling. No babysitting.
Native XLM disbursement across single or multiple recipients. Conditional payouts and recurring transfers handled out of the box.
Workflows are stored off-chain for speed, but their hash is anchored on Stellar — making every configuration tamper-evident and fully auditable.
Complex conditional logic lives in Rust-based Soroban contracts — the safety of smart contracts without forcing you to write them for every simple flow.
Signed transactions, workflow validation, rate limiting, and execution safeguards baked in before anything touches the ledger.
Frontend → React (Workflow dashboard, YAML editor, live logs)
Backend → Express + Go (API gateway, execution engine, scheduler)
Blockchain → Stellar + Soroban (XLM payments, Rust smart contracts)
noire/
│
├── apps/
│ └── dashboard/ ← React · Workflow editor + execution logs
│
├── services/
│ ├── parser/ ← Go · YAML ingestion & validation
│ ├── workflow-engine/ ← Go · Core execution runtime
│ ├── scheduler/ ← Go · Time & event trigger management
│ ├── payments/ ← Go · Stellar transaction handler
│ └── api/ ← Express · External-facing API gateway
│
├── contracts/
│ └── stellar/ ← Rust · Soroban smart contracts
│
├── sdk/
│ └── js/ ← TypeScript SDK for integrators
│
└── infra/ ← Docker, Compose, CI pipelines
Each service owns one concern and one concern only. Modular by design.
1. Write → Author your workflow in YAML
2. Validate → NOIRE checks syntax + logic, previews execution
3. Deploy → Workflow stored off-chain, hash anchored on Stellar
4. Trigger → Event fires (signup, timer, condition met)
5. Execute → Engine processes YAML, sends XLM via Stellar
6. Verify → Transaction recorded on-chain. Fully transparent.
- Automated payouts — reward contributors when milestones are hit
- Subscription payments — recurring billing without a payment processor
- Airdrops — conditional token distribution at scale
- Payroll automation — time-triggered disbursement to team wallets
- NGO fund distribution — transparent, auditable grant flows
- Game reward engines — in-game economies that run themselves
Clone the repository
git clone https://github.com/yourusername/noire.git
cd noireInstall dependencies
pnpm installStart all services
docker-compose upLaunch the dashboard
cd apps/dashboard
npm run devNo other chain makes micro-payment automation this practical.
To become the standard automation layer for Web3 financial flows — where anyone can define payment logic, no smart contract expertise required, and everything runs transparently on-chain.
The same way no one writes raw SQL to build a web app anymore, no one should write raw contract code to automate a payment.
This project lives and dies by the community that builds it. If you're interested in any layer of the stack — Rust contracts, Go services, React dashboard, SDK design, or documentation — there is meaningful work waiting for you.
Open an issue. Start a discussion. Ship a PR.
MIT — free to use, fork, and build upon.
NOIRE — Automate value. With intent.