rune

KO | EN

gitlite — search

#python #react #golang #go #machine-learning #rust #deep-learning #docker #windows #awesome #cli #kubernetes #security #mcp

(★ 12)

Describe your workflow. Automate your world.

rune Latest Version Download

Download Latest Version (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

<h3 align="center">Describe your workflow. <strong><em>Automate your world.</em></strong></h3>

---

Rune is an open-source workflow automation platform that lets you design, execute, and monitor complex automations through a visual interface.

Whether you're orchestrating API calls, processing data pipelines, or building multi-step integrations, Rune makes it simple to go from idea to execution.

We built Rune because automation shouldn't require a degree in distributed systems. Connect your services, define your logic, and let Rune handle the rest.

---

## Table of Contents

- [Table of Contents](#table-of-contents)
- [Features](#features)
- [Quick Start](#quick-start)
  - [What Gets Started](#what-gets-started)
  - [Stopping Services](#stopping-services)
- [Architecture](#architecture)
- [Development](#development)
  - [Prerequisites](#prerequisites)
  - [Commands](#commands)
    - [Startup \& Local Dev](#startup--local-dev)
    - [Testing](#testing)
    - [Linting \& Formatting](#linting--formatting)
    - [Other Utility Commands](#other-utility-commands)
  - [Project Structure](#project-structure)
- [Why Rune?](#why-rune)
- [Contributing](#contributing)
- [License](#license)

---

## Features

**Visual Workflow Designer:**
Build automations by dragging and dropping nodes onto a canvas. Connect them visually, configure their behavior, and watch your workflow come to life.

**Extensible Node System:**
A growing library of nodes for API calls, conditional logic, parallel execution, data transformation, and more. Each node is a composable building block that handles one job well.

**Real-Time Execution Monitoring:**
Watch your workflows execute node-by-node with live WebSocket updates. Debug issues as they happen, not after the fact.

**AI Assistants**

<table>
<tr>
<td width="80" align="center">
<picture>
<source srcset="assets/smith_white.svg" media="(prefers-color-scheme: dark)">
<img src="assets/smith_black.svg" width="48" alt="Smith"/>
</picture>
</td>
<td><strong>Smith</strong> - Describe what you want in plain English. Smith translates your intent into a working workflow definition. Iterate through conversation until it's exactly right.</td>
</tr>
<tr>
<td width="80" align="center">
<picture>
<source srcset="assets/scryb_white.svg" media="(prefers-color-scheme: dark)">
<img src="assets/scryb_black.svg" width="28" alt="Scryb"/>
</picture>
</td>
<td><strong>Scryb</strong> - Automatically generate documentation for your workflows. Scryb analyzes your automation and produces clear, readable explanations tailored to your audience.</td>
</tr>
</table>

**Secure Credential Management:**
Store API keys, OAuth tokens, and secrets with encryption at rest. Share credentials with team members without exposing sensitive values.

**Collaboration Built In:**
Share workflows with granular permissions. Owners, editors, and viewers each see what they need. Full audit trail for compliance.

---

## Quick Start

The fastest way to get Rune running is with Docker:

```bash
# Clone the repository
git clone https://github.com/rune-org/rune.git
cd rune

# Copy the environment template and set your variables
cp .env.example .env

# Start all services
make up
```

Once the containers are running, open `http://localhost:3000` in your browser.

### What Gets Started

| Service | Port | Description |
|---------|------|-------------|
| Frontend | 3000 | Web application |
| API | 8000 | REST API |
| RTES | 8080 | Real-time execution streaming |
| Worker | N/A | Execution engine background worker |
| Archivist | N/A | Data archiver and maintainer |
| Scheduler | N/A | Scheduled workflow trigger service |
| PostgreSQL | 5432 | Primary database |
| MongoDB | 27017 | Execution history |
| Redis | 6379 | State and caching |
| RabbitMQ | 5672 / 15672 | Message broker |
| OpenObserve | 5080 | Observability platform |
| OpenTelemetry | 4317 / 4318 | Telemetry collector |

### Stopping Services

```bash
make down
```

---

## Architecture

Rune follows a polyglot microservices architecture, using the right tool for each job:

- **API (Python/FastAPI)** - Handles authentication, workflow CRUD, credential management, and orchestration
- **Worker (Go)** - Executes workflows recursively, node by node, with fault tolerance
- **RTES (Rust)** - Streams execution state in real-time over WebSockets
- **Frontend (Next.js/React)** - Visual canvas built on React Flow
- **Scheduler (Python)** - Polls PostgreSQL for due scheduled workflows and publishes them to RabbitMQ

---

## Development

### Prerequisites

The API service requires **uv** for dependency management:

```bash
pip install uv
```

See [uv installation guide](https://docs.astral.sh/uv/getting-started/installation/) for other methods.

### Commands

We use a root `Makefile` to orchestrate common development tasks across all services.

#### Startup & Local Dev

```bash
make install          # Install all dependencies (frontend, API, worker, archivist, scheduler)
make dev-infra-up     # Start backing services (Postgres, Redis, RabbitMQ, MongoDB, etc.)
make dev              # Start dev infra and all services in development mode
make dev-infra-down   # Stop backing services
```

Alternatively, you can start individual services in separate terminals:
```bash
make web-dev         # Frontend on :3000
make api-dev         # API on :8000
make worker-dev      # Background worker
make rtes-dev        # Real-time execution service
make archivist-dev   # Archivist worker
make scheduler-dev   # Scheduled workflow trigger
```

#### Testing

```bash
make test             # Run all tests (frontend, API, worker)

# Target specific test suites
make web-test         # Frontend tests (Vitest)
make worker-test      # Go worker tests
make dsl-test         # DSL tests

# API tests (requires separate test database/broker infrastructure)
make test-infra-up    # Start API test infrastructure
make api-test         # Run API tests (pytest)
make test-infra-down  # Stop API test infrastructure
```

#### Linting & Formatting

```bash
make lint             # Run linters for all services (eslint, ruff, go vet, etc.)
make format           # Automatically format code for all services
make typecheck        # Check TypeScript types for frontend
```

#### Other Utility Commands

```bash
make build            # Build frontend and worker
make dsl-generate     # Regenerate TypeScript, Python, and Go types from DSL definition
make logs             # Follow all Docker Compose logs
make up               # Start full Docker Compose stack
make down             # Stop full Docker Compose stack
```

### Project Structure

```
rune/
├── apps/
│   └── web/                 # Next.js frontend
│       ├── content/         # Docs site pages
│       ├── public/          # Static assets
│       └── src/             # Application source
├── services/
│   ├── api/                 # FastAPI backend
│   ├── rune-worker/         # Go execution engine
│   ├── rtes/                # Rust real-time service
│   ├── archivist/           # Python data archiver
│   └── scheduler/           # Python scheduled workflow trigger
└── docker-compose.yml
```

---

## Why Rune?

In ancient times, runes were symbols of power, symbols of magic, each one encoding knowledge that could be combined to express complex ideas. Rune, the platform, follows the same philosophy: simple, composable building blocks that combine into something greater.

But beyond the name, we built Rune because:

**Automation should be accessible.** You shouldn't need to understand message queues, distributed locking, or retry patterns to automate a business process. Rune handles the infrastructure so you can focus on the logic.

**Visibility matters.** When something goes wrong at 2 AM, you need to know exactly which step failed and why. Real-time monitoring and full execution history make debugging straightforward.

**Security isn't optional.** Credentials encrypted at rest, role-based access control, and audit logging come standard. Not as an enterprise add-on.

**Open source wins.** Your automation platform shouldn't be a black box you can't inspect, extend, or self-host.

---

## Contributing

We welcome contributions of all kinds. Whether it's fixing a bug, improving documentation, or proposing a new feature, read the **[Contributing Guide](CONTRIBUTING.md)** to get started.

---

## License

Rune is open source software. See [LICENSE](LICENSE) for more details.

rune

rune Latest Version Download

Today's picks

Was this content helpful?

Recent Feedback

rune

rune Latest Version Download

Today's picks

Was this content helpful?

Recent Feedback

Download README