https://github.com/veiluxlabs/veilux-binary
VEILUX - a featherweight, privacy-first, AI-native modular blockchain. Canton-style privacy, pluggable Prisms (AI/Ollama, Token, NFT, PhotonVM contracts).
https://github.com/veiluxlabs/veilux-binary
ai blockchain canton fintech modular-blockchain nft ollama privacy rust smart-contracts web3 zero-knowledge
Last synced: 27 days ago
JSON representation
VEILUX - a featherweight, privacy-first, AI-native modular blockchain. Canton-style privacy, pluggable Prisms (AI/Ollama, Token, NFT, PhotonVM contracts).
- Host: GitHub
- URL: https://github.com/veiluxlabs/veilux-binary
- Owner: VeiluxLabs
- License: mit
- Created: 2026-06-05T00:20:22.000Z (28 days ago)
- Default Branch: main
- Last Pushed: 2026-06-05T03:57:56.000Z (27 days ago)
- Last Synced: 2026-06-05T04:14:38.345Z (27 days ago)
- Topics: ai, blockchain, canton, fintech, modular-blockchain, nft, ollama, privacy, rust, smart-contracts, web3, zero-knowledge
- Language: Rust
- Homepage: https://github.com/VeiluxLabs/Veilux-Binary
- Size: 155 KB
- Stars: 0
- Watchers: 0
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- Contributing: CONTRIBUTING.md
- License: LICENSE
- Security: docs/security.md
- Roadmap: docs/roadmap.md
Awesome Lists containing this project
README
# VEILUX
[](https://github.com/VeiluxLabs/Veilux-Binary/actions/workflows/ci.yml)
[](https://github.com/VeiluxLabs/Veilux-Binary/actions/workflows/release.yml)
[](https://www.npmjs.com/package/@veilux/sdk)
[](#license)
> **Veil** (privacy by default) + **Lux** (light / illumination) — a featherweight, privacy-first, AI-native modular blockchain.
Repository: **[github.com/VeiluxLabs/Veilux-Binary](https://github.com/VeiluxLabs/Veilux-Binary)** · TypeScript SDK: **[npmjs.com/package/@veilux/sdk](https://www.npmjs.com/package/@veilux/sdk)** · Releases: **[binaries](https://github.com/VeiluxLabs/Veilux-Binary/releases)**
VEILUX is built around three ideas:
1. **A featherweight core.** The *Photon* kernel knows almost nothing. It defines the data shapes, one extension trait (`Prism`), a pipeline (`Cascade`), and a content-addressed state. That's it. Everything heavy is an add-on you compile in only if you need it. Release binaries are optimized for size (`opt-level = "z"`, LTO, stripped).
2. **Everything is a Prism (add-on).** A *Prism* is a self-contained capability. Shipped Prisms: **AI** (+ optional Ollama), **Storage**, **Token** (ERC-20-like), **NFT** (ERC-721-like), **Contract** (PhotonVM), and **Bridge** (cross-chain to Cosmos/Solana/EVM). They **cascade**: one Prism can trigger another (the AI Prism offloads large results to the Storage Prism automatically). Add your own by implementing one trait.
3. **Privacy by ledger (VeilLedger).** The *Veil* layer gives you one logically shared ledger where **no participant sees data they aren't a stakeholder of**. Every node agrees on the same Merkle root of *blinded commitments*, while contents are sealed per-party into encrypted **views** and stored in per-party **sub-ledgers**.
```
╦ ╦╔═╗╦╦ ╦ ╦═╗ ╦
╚╗╔╝║╣ ║║ ║ ║╔╩╦╝
╚╝ ╚═╝╩╩═╝╚═╝╩ ╚═
featherweight · privacy-first · AI-native
```
## Token
| | |
|---|---|
| Ticker | `LUX` |
| Subunit | `lumen` (1 LUX = 10¹⁸ lumen) |
## What is VEILUX?
VEILUX is an original **Layer-1 blockchain**, written entirely in **Rust** and
compiled to a single, native, featherweight binary (`veilux`). It is not a fork
and does not embed a third-party EVM — it is built from the ground up around
three principles: **a tiny core, everything-as-a-module, and privacy by
default.**
### The technology
- **100% Rust, native binary.** Compiles straight to machine code (no
interpreter, no VM runtime). Memory-safe with no garbage collector, and
deterministic — every node computes identical results, which is what BFT
consensus requires.
- **Featherweight.** Release binaries are size-optimized (`opt-level="z"`, LTO,
stripped, `panic="abort"`) and typically only ~0.6–0.9 MB per platform. The
core kernel depends on just four small crates — no heavyweight database or
networking framework.
- **Multi-platform.** One codebase ships to six targets: Linux (glibc + static
musl, x86_64 + ARM64), Windows x86_64, and macOS (Intel + Apple Silicon).
- **Modular by construction.** Capabilities are *Prisms* you compile in only
when needed, so you never pay for what you don't run.
### How it works
| Layer | What it does |
|-------|--------------|
| **Photon** (kernel) | Data shapes, the `Prism` trait, the cascade pipeline, and a BLAKE3 content-addressed state. Deliberately minimal. |
| **Aurora** (consensus) | Stake-weighted Byzantine fault-tolerant consensus: 2/3+ finality, deterministic proposer selection, quorum-synchronized proposer failover, equivocation detection. |
| **Veil** (privacy) | One logically shared ledger; each event is sealed per-party with ChaCha20-Poly1305, while all nodes agree on a Merkle root of blinded commitments. Includes scoped selective disclosure for auditors/regulators. |
| **Store** | Persistent block log + atomic state snapshots; the chain reloads on restart. |
| **Network** | Lightweight TCP gossip for proposals, votes, blocks, and sync. |
### Features
**Built-in Prisms (add-ons):**
| Prism | Capability |
|-------|------------|
| **Token** | Fungible tokens (ERC-20-style): transfer, approve, mint, burn |
| **NFT** | Non-fungible tokens & collections (ERC-721-style) |
| **Contract** | PhotonVM — a deterministic stack-based smart-contract VM |
| **AI** | On-chain model registry + deterministic inference, with optional local LLM execution via Ollama |
| **Storage** | Content-addressed blob storage with reference-counted pinning |
| **Bridge** | Guardian-attested cross-chain transfers to Cosmos, Solana, and EVM chains |
**Developer experience:**
- **JSON-RPC API** (`veilux serve`) — a local dev node, like Anvil/Ganache
- **WebSocket subscriptions** — real-time block notifications
- **SDKs** — Rust (`veilux-sdk`) and TypeScript (`@veilux/sdk`, on npm), with
byte-compatible signing so clients in either language verify on-chain
- **Full CI/CD** — multi-platform release binaries, Docker images, and automatic
npm publishing
### What makes it different
1. **AI-native.** AI is a first-class Prism with deterministic, verifiable
inference — not a bolt-on. It can also drive local LLMs through Ollama.
2. **Banking-grade privacy.** The VeilLedger model keeps data confidential from
competitors while remaining provably transparent to authorized regulators,
enforced by cryptography rather than policy.
3. **Featherweight & modular.** A tiny core plus opt-in Prisms means stronger
security, smaller binaries, and long-term maintainability.
4. **Cross-chain by design.** The Bridge Prism connects VEILUX to other
ecosystems out of the box.
### Who it's for
- **Financial institutions** building confidential finance and tokenized assets
- **Decentralized AI** applications needing verifiable on-chain inference
- **Enterprises** coordinating multi-party workflows over private-but-verifiable data
- **Web3 developers** shipping dApps with the Rust or TypeScript SDK
### Status
VEILUX is a fully functional chain: live multi-node BFT consensus, persistence,
networking, privacy, six Prisms, and JSON-RPC + WebSocket APIs with Rust and
TypeScript SDKs — all covered by tests and continuous integration.
## Workspace layout
```
veilux/
├── kernel/ # Photon: featherweight core (no EVM, ~zero heavy deps)
│ ├── crypto.rs # BLAKE3 hashing + Merkle roots
│ ├── types.rs # Command / Event / Block / PartyId / Visibility
│ ├── prism.rs # the Prism trait — the one extension point
│ ├── cascade.rs # the Prism pipeline / executor
│ └── state.rs # content-addressed authenticated state
├── veil/ # VeilLedger privacy
│ ├── view.rs # encrypted per-party views (ChaCha20-Poly1305)
│ ├── identity.rs # Ed25519 signing identities
│ ├── disclosure.rs # scoped selective disclosure (auditor/regulator)
│ ├── projection.rs # split a block into per-party views
│ └── ledger.rs # per-party sub-ledgers
├── consensus/ # Aurora — stake-weighted BFT (validators, votes, quorum)
├── store/ # append-only block log + state snapshots (persistence)
├── network/ # lightweight TCP gossip (blocks, votes, commands)
├── rpc/ # JSON-RPC contract types + featherweight HTTP server
├── sdk/ # veilux-sdk: Rust client (identity + builders + RPC)
├── sdk-ts/ # @veilux/sdk: TypeScript/JS client for web & Node
├── prisms/
│ ├── ai/ # AI Prism: model registry + inference (+ optional Ollama)
│ ├── storage/ # Storage Prism: content-addressed blobs + pinning
│ ├── token/ # Token Prism: fungible tokens (ERC-20-like)
│ ├── nft/ # NFT Prism: non-fungible tokens (ERC-721-like)
│ ├── contract/ # Contract Prism: PhotonVM smart contracts
│ └── bridge/ # Bridge Prism: cross-chain transfers (Cosmos, Solana, EVM)
└── node/ # assembles kernel + veil + consensus + store + prisms
```
## The cascade
A command is routed to its Prism, which emits events **and** optional derived
commands. Derived commands flow back into the pipeline (bounded depth), so
capabilities compose:
```
submit(ai.infer) ─► AI Prism ─► InferenceCommitted event
└─(large result)─► storage.put ─► Storage Prism ─► Stored event
```
## Privacy model (the VeilLedger design)
- Each event declares a `Visibility`: `Public` or `Parties([...])`.
- The block commits to a Merkle root over **commitments** (blinded hashes), so
every node — even non-stakeholders — agrees on the same global root.
- For each stakeholder, the event is sealed into an **EncryptedView**
(ChaCha20-Poly1305, key derived per party + view).
- Each party keeps a **SubLedger**: the decrypted events it's entitled to, plus
the validated global root.
Result: a non-stakeholder can prove a transaction *happened* without learning
*what* happened.
## Download (prebuilt binaries)
Every tagged release publishes ready-to-run binaries on the
[Releases page](https://github.com/VeiluxLabs/Veilux-Binary/releases):
| Platform | Asset |
|----------|-------|
| Linux x86_64 (glibc) | `veilux--x86_64-unknown-linux-gnu.tar.gz` |
| Linux x86_64 (static musl) | `veilux--x86_64-unknown-linux-musl.tar.gz` |
| Linux ARM64 | `veilux--aarch64-unknown-linux-gnu.tar.gz` |
| Windows x86_64 | `veilux--x86_64-pc-windows-msvc.zip` |
| macOS Intel | `veilux--x86_64-apple-darwin.tar.gz` |
| macOS Apple Silicon | `veilux--aarch64-apple-darwin.tar.gz` |
Each asset ships with a `.sha256` checksum. Example (Linux):
```bash
tar xzf veilux-v0.1.0-x86_64-unknown-linux-gnu.tar.gz
cd veilux-v0.1.0-x86_64-unknown-linux-gnu
./veilux info
```
Or pull the container image:
```bash
docker run --rm ghcr.io/veiluxlabs/veilux-binary:latest info
```
## Build & run
> Requires the Rust toolchain (`rustup`, stable 1.85+). The workspace compiles
> cleanly and all tests pass.
```bash
cd veilux
cargo build --release # featherweight, size-optimized binaries
cargo test --workspace # kernel/veil/prism unit tests (all green)
cargo run --bin veilux -- info # show kernel + installed prisms
cargo run --bin veilux -- demo # private AI + storage + audit demo
cargo run --bin veilux -- run # persistent node (BFT consensus + disk store)
cargo run --bin veilux -- serve # dev RPC + WebSocket node (http :8645, ws :8646)
```
The `run` command opens a data directory (default `./veilux-data`), loads any
existing chain from disk, produces+persists a block, and reports the Aurora BFT
proposer slot. Re-running it shows the chain growing across restarts.
For a live multi-node BFT network, use `veilux validator` (see
`docs/consensus-networking.md`) — three validators reach 2/3+ finality over TCP
and stay byte-for-byte in sync.
See **`docs/INSTALL.md`** for a full setup, troubleshooting, and library quick-start.
## Documentation
| Doc | What's inside |
|-----|---------------|
| `docs/INSTALL.md` | Install, build, run, troubleshoot, CI/CD, Docker |
| `docs/architecture.md` | System design, cascade, state model |
| `docs/add-ons.md` | Per-Prism specs (AI, Storage, Token, NFT, Contract) + how to build your own |
| `docs/consensus-networking.md` | Aurora BFT consensus, persistence, and gossip transport |
| `docs/rpc-sdk.md` | JSON-RPC API + Rust & TypeScript SDKs for building applications |
| `docs/ai-ollama.md` | Running real AI models via Ollama |
| `docs/privacy-model.md` | Deep VeilLedger banking-grade privacy research |
| `docs/security.md` | Threat model + exploitation review + what runs safely |
| `docs/roadmap.md` | Future add-ons the chain needs next |
| `CHANGELOG.md` | Version history (Keep a Changelog format) |
## Writing your own Prism
```rust
use veilux_kernel::{Command, Event, Prism, PrismError, PrismInfo, PrismOutput, StateTree};
struct HelloPrism;
impl Prism for HelloPrism {
fn info(&self) -> PrismInfo {
PrismInfo { name: "hello", description: "says hi", version: "1.0" }
}
fn handle(&self, cmd: &Command, _state: &mut StateTree) -> Result {
let event = Event {
source_command: cmd.id(),
prism: "hello".into(),
visibility: cmd.visibility.clone(),
payload: b"hi".to_vec(),
};
Ok(PrismOutput::single(event, 100))
}
}
```
Install it with `cascade.install(Box::new(HelloPrism))` and it's live. Full spec
and checklist in `docs/add-ons.md`.
## SDKs
Build apps against VEILUX in Rust or TypeScript:
- **TypeScript / JavaScript** — [`@veilux/sdk`](https://www.npmjs.com/package/@veilux/sdk)
[](https://www.npmjs.com/package/@veilux/sdk)
[](https://www.npmjs.com/package/@veilux/sdk)
Source in [`sdk-ts/`](sdk-ts). Byte-compatible signing with the node, command
builders, typed RPC client, and WebSocket block subscriptions.
```bash
npm install @veilux/sdk
```
```ts
import { Client, PartyIdentity, builders, subscribeBlocks } from "@veilux/sdk";
const client = new Client("http://127.0.0.1:8645");
const alice = PartyIdentity.fromSeed("alice", new Uint8Array(32).fill(1));
await client.submit(alice.sign(
builders.tokenCreate("alice", "Public", 0, "Gold", "GLD", 18, 1_000_000n, true)));
subscribeBlocks("ws://127.0.0.1:8646", { onBlock: (b) => console.log(b.height) });
```
- **Rust** — [`veilux-sdk`](sdk) crate. Same surface, native types.
See [`docs/rpc-sdk.md`](docs/rpc-sdk.md) for the full API.
## Contributing
Contributions are welcome! Open PRs against the **`develop`** branch. See
[`CONTRIBUTING.md`](CONTRIBUTING.md) for the branching model, commit conventions,
and the checks CI runs. Adding a capability is as simple as writing a Prism —
no kernel fork required (see [`docs/add-ons.md`](docs/add-ons.md)).
## License
Licensed under either of:
- MIT license ([LICENSE-MIT](LICENSE-MIT))
- Apache License 2.0 ([LICENSE-APACHE](LICENSE-APACHE))
at your option.
## Contact
- Telegram: [@Winnodexx](https://t.me/Winnodexx)
- Email: [nathan@winnode.xyz](mailto:nathan@winnode.xyz)
## Author
Created and maintained by **nathan**. Original work — © 2026 nathan.