Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Introduction

Tutti is a lightweight CLI tool for orchestrating processes - run, coordinate, and monitor multiple local processes with ease.

What is Tutti

Tutti helps developers manage complex local development environments where multiple services need to run simultaneously. Instead of opening multiple terminals and starting each service manually, you describe everything in a simple TOML configuration file and start them all with one command.

Why Use Tutti

  • Simplified Development - No need to remember complex startup sequences
  • Dependency Management - Services start in the correct order based on dependencies
  • Unified Logging - All service logs in one place with colored prefixes
  • Easy Environment Setup - New team members can start the entire stack with one command
  • Lightweight Alternative - No Docker overhead for local development

How It Works

  1. Create a tutti.toml configuration file describing your services
  2. Run tutti-cli run -f tutti.toml to start all services
  3. Monitor colored logs from all services in one terminal
  4. Press Ctrl+C to gracefully stop all services

Tutti is perfect for microservice architectures, full-stack development, or any scenario where you need to coordinate multiple local processes.

Installation

Via Cargo

The easiest way to install tutti-cli:

cargo install tutti-cli

Prebuilt Binaries

Download prebuilt releases from the Releases page.

From Source

Clone the repository and build:

git clone https://github.com/ya7on/tutti
cd tutti
cargo build --release

The binary will be available at target/release/tutti-cli.

Configuration

Tutti uses TOML files to configure services. By default, it looks for a tutti.toml file in the current directory.

Configuration Structure

Root Level

version = 1

[services]
# Services are defined here

Root Parameters

  • version (optional, defaults to 1) - Configuration format version

Services

Each service is described in a [services.service_name] section:

[services.my_service]
cmd = ["command", "arg1", "arg2"]
cwd = "/path/to/working/directory"
env = { VAR1 = "value1", VAR2 = "value2" }
deps = ["other_service"]
restart = "always"

Service Parameters

  • cmd (required) - Array of strings with command and arguments to run the service
  • cwd (optional) - Working directory for the command execution
  • env (optional) - Environment variables for the service
  • deps (optional) - List of dependencies - names of other services that must be started before this one
  • restart (optional, defaults to never) - Restart policy for the service (always, never)

Parameter Requirements

  • cmd cannot be an empty array
  • cmd cannot contain empty strings
  • deps can only contain names of existing services
  • restart can only be one of always, never

Environment Variables

Environment variables can be defined in two ways:

Inline Object

[services.api]
cmd = ["node", "server.js"]
env = { NODE_ENV = "development", PORT = "3000" }

Separate Section

[services.api]
cmd = ["node", "server.js"]

[services.api.env]
NODE_ENV = "development"
PORT = "3000"

Configuration Examples

Simple Service

version = 1

[services.hello]
cmd = ["echo", "Hello World"]

Service with Environment Variables

version = 1

[services.web]
cmd = ["python", "-m", "http.server"]
env = { PORT = "8000" }
cwd = "./public"

Services with Dependencies

version = 1

[services.database]
cmd = ["postgres", "-D", "./data"]

[services.api]
cmd = ["node", "api.js"]
deps = ["database"]
env = { DB_HOST = "localhost" }

[services.frontend]
cmd = ["npm", "start"]
deps = ["api"]
cwd = "./frontend"

In this example, services will start in order: database → api → frontend.

Complex Multi-Service Setup

version = 1

[services.redis]
cmd = ["redis-server", "--port", "6379"]

[services.postgres]
cmd = ["postgres", "-D", "./pgdata", "-p", "5432"]

[services.api-auth]
cmd = ["python", "-m", "auth_service"]
deps = ["postgres", "redis"]
cwd = "./services/auth"
[services.api-auth.env]
DATABASE_URL = "postgresql://localhost:5432/auth"
REDIS_URL = "redis://localhost:6379"

[services.api-users]
cmd = ["node", "users-service.js"]
deps = ["postgres"]
cwd = "./services/users"
[services.api-users.env]
DB_HOST = "localhost"
DB_PORT = "5432"

[services.api-gateway]
cmd = ["./api-gateway"]
deps = ["api-auth", "api-users"]
[services.api-gateway.env]
AUTH_SERVICE = "http://localhost:8001"
USERS_SERVICE = "http://localhost:8002"

[services.frontend]
cmd = ["npm", "run", "dev"]
deps = ["api-gateway"]
cwd = "./frontend"
env = { REACT_APP_API_URL = "http://localhost:8000" }

Usage

Basic Commands

Run All Services

tutti-cli run --file tutti.toml

Run Specific Services

You can specify which services to start:

tutti-cli run --file tutti.toml service1 service2

When you specify services, all their dependencies will be automatically started as well.

Command Options

tutti-cli run

Starts services defined in the configuration file.

Options:

  • --file / -f (required) - Path to the TOML configuration file
  • services (optional) - List of service names to start

Examples:

# Start all services
tutti-cli run -f tutti.toml

# Start specific services
tutti-cli run -f config.toml api database

# Using long form
tutti-cli run --file ./config/tutti.toml frontend

Process Management

Press Ctrl+C to stop all services gracefully

Log Output

All service logs are combined into a single output stream with prefixes:

[database] Starting PostgreSQL on port 5432
[api] Server listening on http://localhost:3000
[frontend] Development server started on port 8080
[database] Ready to accept connections

Motivation

Tutti was created to solve a very common problem for developers who work with multiple local services. When working on modern backend systems, it is normal to have several services that depend on each other. For example, one service might need a database, another might need that service, and so on. This often means opening several terminal tabs and manually running each command in the right order. It is not hard, but it is repetitive and annoying.

Many people solve this with Docker and docker-compose. Docker lets you define dependencies and start everything with one command. But for many developers, especially on macOS, Docker builds are slow. Even a small code change can trigger a long rebuild. That slows down development a lot. In some cases, cross-compiling or mounting volumes is an option, but it adds complexity and is not always practical. If the services are already runnable locally, Docker becomes unnecessary overhead.

Tutti is designed to remove that overhead. It lets developers define services in a simple TOML config file: the command to run, working directory, environment variables, and dependencies. Tutti then starts the services in the correct order, streams all logs to one place, and cleanly shuts everything down with a single Ctrl+C.

The goal is not to replace Docker in production. The goal is to make local development faster and simpler. Tutti gives developers a single command to bring up their entire local stack without containers, without long build times, and without juggling multiple terminals. It is like docker-compose, but for real processes on your machine.