---
title: "Arete"
description: "Build Solana apps with live blockchain data"
editUrl: true
head: []
template: "doc"
sidebar: {"hidden":false,"attrs":{}}
pagefind: true
draft: false
---

**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

  
    **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 →](/agent-skills/setup-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 →](/agent-skills/overview/)

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

    Full API reference available.

    [Quickstart →](/using-stacks/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.

**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.

```tsx
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(())
}
```

:::tip[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. **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:

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

    Choose React, TypeScript, or Rust templates.

    [Start here →](/using-stacks/quickstart/)

  
  
    **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 →](/using-stacks/connect/)

  

---

## 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.

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

    [Set up your tools →](/agent-skills/setup-tools/)

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

    [View prompts →](/agent-skills/prompts/)

  

---

## Build Custom Streams

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

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

    Define entities, write transformations, deploy to Arete Cloud.

    [Build now →](/building-stacks/your-first-stack/)

  
  
    **Architecture & concepts** — Understand the full Arete system.

    Learn about entities, mappings, aggregations, and deployment.

    [Learn more →](/using-stacks/how-it-works/)