Typed, supervised dataflow on the BEAM
Turn AI-written software into a system you can understand. Small, typed blocks. Explicit connections. Checked before it runs.
{:bloccs, "~> 0.9"}
AI can write the implementation. You should still be able to see the architecture.
With bloccs, you and your AI work on the same small manifest. The graph makes the connections visible. The compiler checks the contracts. You stay in the loop.
Each blocc says what comes in, what goes out, and what it can touch. Ordinary Elixir does the work inside.
Versioned schemas make every connection explicit. Ports must agree before a network compiles.
Small functions you can read and test. Same input, same output, with no hidden side effects.
HTTP, database, and other capabilities are declared at the boundary. The badge makes them visible.
Write a TOML manifest, or have your AI edit one. Review the graph and the functions behind it.
The compiler validates typed ports, schema compatibility, and declared capabilities.
Compile to a Broadway supervision tree, with OTP fault tolerance, back-pressure, and tracing.
Confidence, before runtime
Change a contract. Remove a capability. See where the network stops.
Event@1 /All connections agree
mix bloccs.validate events.bloccs
5 nodes · 4 edges · 2 declared effects. Every edge connects ports that agree on their schema, and no node reaches past what it declared. The network compiles.
Rejected · schema mismatch on by-type.known → deliver.event
by-type.known emits Event@1. deliver.event expects Order@1. An edge may only connect ports that agree on their schema, so the compiler stops here — before a single message moves.
Rejected · undeclared effect in deliver
deliver declares no effects, but its effect shell writes to the database. Effects are declared capabilities, not loose function calls: a node that hasn't declared the database cannot reach for it.
Illustrated validation states, based on bloccs contracts.
Real backend patterns. Explicit architecture. Code you own.
Ingest, validate, route, fan out to effects. Dead-letter the unknowns. Every hop typed and traced.
Retrieve, rank, call a model, gate the action. Capability boundaries and simulation mode are built in.
Branch on state, enforce idempotency, recover under supervision. The graph makes the money path legible.
The library and the dashboard are open source. Everything you need to define, run, and observe your networks.
The library. A readable manifest becomes a running system.
# validate.bloccs — one node
[node]
id = "validate"
kind = "transform"
[ports.in]
order = { schema = "Order@1" }
[ports.out]
valid = { schema = "Order@1" }
[effects] # none declared -> none allowed
[contract]
pure_core = "MyApp.Orders.Validate.transform/2"
effect_shell = "MyApp.Orders.Validate.execute/2"
The dashboard. Follow every message through the system.
Mount one router macro to inspect the live topology, messages, timings, and what actually executed.
See the dashboardWhere bloccs fits, what it compiles to, and what to expect.
Join the discussionThey aim at opposite outcomes. No-code platforms like Bubble abstract code away so non-engineers can ship, and the result only runs inside the vendor's closed runtime. bloccs is built for engineers: the diagram is a typed spec that compiles to plain Elixir you own, review in a normal PR, and run anywhere. Its job is to make AI-written code reviewable at the speed AI produces it, not to hide the code from you.
Claude writes bloccs — it isn't the alternative to it. Freeform generation means reviewing thousands of lines and trusting the model. A manifest means reviewing a small graph and trusting a compiler that catches mis-wired stages and undeclared effects before anything runs.
Effects are declared capabilities, not loose function calls. A block that doesn't declare HTTP or database access can't reach for it: the compiler rejects any node whose code touches the world outside its declared effects. That shrinks an AI-written change to a graph and a handful of small functions you can read, instead of thousands of lines of generated glue.
A Broadway supervision tree on the BEAM. Generated source lands in _build/ so you can read, review, and debug it like any other Elixir — no hidden runtime.
Yes. bloccs is Elixir/OTP and runs on the BEAM — blocks are real Elixir functions and it compiles to a Broadway supervision tree. If your backend already lives on Erlang/Elixir it drops in; if it doesn't, this isn't a way to skip learning the platform.
n8n and Zapier are closed SaaS automation — your flow runs on their runtime, untyped. LangGraph orchestrates agents in freeform Python. Temporal gives durable execution but you still hand-write every line. bloccs is the one where a typed graph compiles to plain code you own, with the compiler checking wiring and declared effects before it runs.
Within its lane, yes. The runtime is supervised, back-pressured, and capability-checked, with retry, timeout, idempotency, and telemetry wired into every node, on the same BEAM substrate (Broadway/OTP) hardened behind Discord and WhatsApp. What's pre-1.0 is the surface: the public API and manifest format can shift between minor releases, so pin a version. The one thing bloccs leaves out by design is durability — in-flight messages live in memory, so put Oban or a broker at the edges for work that must survive a restart.
When the work isn't a graph of typed stages. A single ingest → process → batch pipeline is Broadway's job, and bloccs would only add a layer. Work that must survive restarts, run exactly-once, or be scheduled is a durable job — that belongs in Oban, at the edges of a network. "Component A must be incapable of calling component B" is a module-dependency rule that boundary enforces at compile time, which bloccs doesn't replace. Ad-hoc state or one-off concurrency is a plain GenServer or Task. And it isn't a web page or content-block builder. bloccs earns its keep once you have a graph of effectful stages you want declared, checked, and reviewable.
The core is open source and free under Apache-2.0: the library plus a dashboard to watch systems run. A commercial Pro tier (bloccs.pro) is for teams in production — governance and audit, guarantees, support, and a hosted option. Free earns adoption; Pro is what a company needs once this is load-bearing.
Start with a blocc. Build something you understand.
Get started{:bloccs, "~> 0.9"}
We can't find the internet
Attempting to reconnect
Something went wrong!
Attempting to reconnect