Arete

For AI agents: the documentation index is at llms.txt (full corpus: llms-full.txt). A markdown source for this page is /index.md.

Programmable data streams for Solana. No indexers. No polling. No infrastructure to manage.

Arete streams real-time blockchain data directly to your app. Define what data you need and Arete transforms on-chain events into typed, live feeds — consumed via React hooks, TypeScript streams, or Rust clients.

---

Choose Your Path

I'm New to Coding

Start here if you’ve never built an app. We’ll walk you through setting up AI tools that write code for you.

No programming experience required.

Get started →

I Use AI Coding Tools

Already have Cursor, Claude Code, or similar? Paste one prompt and your AI handles the rest.

Works with 30+ AI coding assistants.

Build with AI →

I'm a Developer

Know React, TypeScript, or Rust? Jump straight to the SDK and start streaming data in minutes.

Full API reference available.

Quickstart →

---

What is Arete?

Arete connects your app to live Solana blockchain data. Instead of polling RPCs or building custom indexers, you define what data you want and Arete streams it to you as it happens on-chain.

1

Solana

On-chain data

→

2

Arete

Transforms + streams

→

3

Your App

Live feed

Think of it like a live database query against the blockchain — you subscribe once and get updates pushed to you automatically.

---

See It In Action

Connect to the public ORE mining stack — a live feed of blockchain mining activity. No account required.

React

import { AreteProvider, useArete } from 'arete-react';
import { ORE_STREAM_STACK } from 'arete-stacks/ore';

function App() {
  return (
    <AreteProvider>
      <LatestRounds />
    </AreteProvider>
  );
}

function LatestRounds() {
  const { views, isConnected } = useArete(ORE_STREAM_STACK);
  const { data: rounds, isLoading } = views.OreRound.latest.use({ take: 5 });

  if (isLoading) return <div>Connecting...</div>;

  return (
    <div>
      <p>{isConnected ? "🟢 Live" : "Connecting..."}</p>
      <ul>
        {rounds?.map((round) => (
          <li key={round.id?.round_id}>
            Round #{round.id?.round_id} — Motherlode: {round.state?.motherlode}
          </li>
        ))}
      </ul>
    </div>
  );
}

TypeScript

import { Arete } from 'arete-typescript';
import { ORE_STREAM_STACK } from 'arete-stacks/ore';

// Connect using the stack (URL is embedded in the stack definition)
const a4 = await Arete.connect(ORE_STREAM_STACK);

for await (const update of a4.views.OreRound.latest.watch({ take: 1 })) {
  if (update.type === 'upsert') {
    console.log(`Round #${update.data.id?.round_id}`);
    console.log(`Motherlode: ${update.data.state?.motherlode}`);
  }
}

Rust

use a4_sdk::prelude::*;
use a4_stacks::ore::{OreStack, OreRound};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let a4 = Arete::<OreStack>::connect().await?;

    let mut stream = a4.views.ore_round.latest().listen().take(1);

    while let Some(round) = stream.next().await {
        println!("Round # {:?}", round.id.round_id);
        println!("Motherlode: {:?}", round.state.motherlode);
    }

    Ok(())
}

Don’t want to write code?

Paste the prompt below into your AI coding assistant — it handles everything.

---

How It Works

Arete handles the full pipeline from chain to client:

1

Solana

On-chain data

→

2

Arete

Transform + stream

→

3

Your App

Live feed

1. Define the data shape you need using a declarative Rust DSL
2. Deploy your definition — Arete manages the infrastructure
3. Stream live updates to any client via WebSocket

---

Capabilities

Feature	Description
Account state	Map fields directly from on-chain accounts
Instructions	Extract arguments and accounts from program instructions
Aggregations	Compute Sum, Count, Max, Min, UniqueCount across events
Computed fields	Derive values from other fields
PDA resolution	Automatically resolve related accounts
Live streaming	Updates pushed via WebSocket as they happen on-chain
Type-safe SDKs	Generated TypeScript and Rust SDKs — share with your team or publish

---

For Developers

Already comfortable with code? Here are the fastest paths:

Quickstart

Scaffold a new app — The CLI creates a complete working project in under 2 minutes.

Choose React, TypeScript, or Rust templates.

Start here →

Connect to a Stack

Add to existing project — Install the SDK and start streaming with a few lines of code.

Works with any React, TypeScript, or Rust project.

Connect now →

---

Build with AI

Paste this into any AI coding assistant (Cursor, Claude Code, Windsurf, or any agent that can read URLs) and it will set up Arete and build an ORE mining dashboard for you:

Read https://docs.arete.run/agent.md and follow the instructions to set up Arete in this project. Then build a React dashboard that shows live ORE mining round data with Tailwind CSS dark theme.

Your AI will install the CLI, learn the SDK patterns, connect to live Solana data, and build the app — all from that one prompt.

New to Coding?

Never used AI coding tools? We’ll walk you through installing Cursor or similar from scratch.

Set up your tools →

Prompt Cookbook

Browse ready-made prompts for dashboards, analytics, and custom data feeds.

View prompts →

---

Build Custom Streams

Want to create your own data feeds? Build stacks that transform on-chain events into structured, streaming data.

Your First Stack

End-to-end tutorial — Build, deploy, and connect to your own custom stack.

Define entities, write transformations, deploy to Arete Cloud.

Build now →

How It Works

Architecture & concepts — Understand the full Arete system.

Learn about entities, mappings, aggregations, and deployment.

Learn more →