repowiserepowise

App

temporalio / temporal

Temporal service

★ 24,418stars on GitHubGoMIT

This connects Repowise to temporalio/temporal's code. It does not install temporal.

Repowise maps public repos from their source. Not affiliated with temporalio. What is Repowise?

github.com/temporalio/temporalIndexed at a2de6d8

What is temporal?

Temporal is a durable execution platform that lets developers build scalable applications without sacrificing productivity or reliability. The Temporal server runs units of application logic called Workflows and automatically handles intermittent failures and retries failed operations. The repository is written in Go. To install it, run brew install temporal. Its code health is 6.7 out of 10 (Fair), ranked #158 of 4,000+ indexed repos. The last commit to temporal was on Oct 6, 2026, and 340 people have contributed.

As of commit a2de6d8, indexed Oct 6, 2026. What it is comes from a model reading the README; the rest is measured from the source and git history, not from the maintainer.

For agentstemporal.md

Repo facts: type, license, health, rank, contributors
temporal facts
TypeApp
LicenseMIT
Code health6.7 / 10 (Fair)
Health rank#158 of 4,000+ indexed repos
Last commitOct 6, 2026
Contributors340
Bus factor8
Size3,156 files, 755,339 lines

Install temporal

Commands copied from the README

  1. 1Install the Temporal CLI with Homebrew.
    brew install temporal

Full install notes on GitHub

Explore temporal

Ask about this code in your agent

This connects Repowise to temporal's code. It does not install temporal. To install temporal, use the install steps.

Useful if you want to change or fork temporal: your agent can ask how it is put together and get answers that cite its files.

How to use temporal

  1. 1Start a local Temporal server with the development configuration.
    temporal server start-dev
  2. 2List the namespaces on the running Temporal server.
    temporal operator namespace list
  3. 3List the workflows on the running Temporal server.
    temporal workflow list

Ask about temporal

Answers come from temporal's README and source, with the files they cite. Two free answers a day without an account.

Featured answer

Temporal is a durable execution platform in the temporalio/temporal repository, written in Go, that runs application logic called Workflows and automatically handles intermittent failures and retries failed operations. The server process starts from cmd/server/main.go, and the service directory acts as the orchestration hub that coordinates history persistence logic, task execution and queue processing, and task matching. The client directory holds client-facing RPC stubs for history, matching, frontend, admin, and operator, along with client-side routing and connection caching, while the common directory supplies shared logging, metrics, dynamic configuration, RPC wiring, namespaces, and persistence glue. The chasm directory defines the core data model and interfaces for typed components and archetypes, and the schema directory embeds the schema filesystem used during database setup. In the layer chart, Application has 812 files, Utility has 597, and Data has 276, so those are the largest areas to explore. To start reading, open cmd/server/main.go first, then the service directory, and then chasm for the data model.

Files per layer in temporal9 layers.

Basis: Inferred · knowledge graph· as of a2de6d8

Want this for your own codebase? Map your repo free

About this page

Get a page like this for your own codebase

Repowise built this map of temporalio/temporal from its source and git history. It parses every symbol, draws the dependency graph, scores each file's health from complexity, duplication, coverage and churn, finds hotspots and owners in the history, and writes documentation for every module. Your coding agent reads the same index over MCP, so its answers cite real files.

Free for 2 public repos, with a page like this one. No card. See how Repowise works

Prefer local? pip install repowise && repowise init indexes your own checkout, no account needed. Star Repowise on GitHub

temporalio/temporal FAQ

What is Temporal?

Temporal is a durable execution platform for building scalable applications. The Temporal server executes units of application logic called Workflows and handles intermittent failures automatically.

How does Temporal work?

Temporal runs Workflows on its server, which retries failed operations automatically. Its service directory coordinates history persistence, task execution, queue processing, and task matching.

How do I install Temporal?

Temporal can be installed with Homebrew using brew install temporal. After installation, temporal server start-dev starts a local server with its dependencies. See the install steps

What language is Temporal written in?

Temporal is written in Go. Go files make up most of the repository's source code by file count.

How is the Temporal code organized?

Temporal groups its code into directories such as service, client, common, chasm, and schema. The cmd/server/main.go file is the server entry point.

Who is Temporal for?

Temporal is for developers who build scalable applications without sacrificing productivity or reliability. It is used to implement Workflows, Activities and Workers.

What license does Temporal use?

Temporal is released under the MIT license, identified as MIT.

Code health

6.7out of 10Fair

Hotspots average 4.8, the place fixes pay off most.

On the leaderboards:#3 of 3 Workflow orchestrators#18 of 28 Go repos

Key features of temporal

  • Runs units of application logic called Workflows in a resilient manner.
  • Automatically handles intermittent failures and retries failed operations.
  • Provides the Temporal CLI to interact with the running Temporal server.
  • Offers a Temporal Web UI for viewing workflows executing on Temporal.
  • Lets developers implement Workflows, Activities and Workers in supported languages.

How temporalio/temporal works

The server process starts from cmd/server/main.go, which is one of the repository's entry points. The service directory is the orchestration hub that coordinates history persistence logic, task execution and queue processing, and task matching. The client directory holds the client-facing RPC stubs for history, matching, frontend, admin, and operator, along with client-side routing and connection caching. The common directory supplies shared building blocks such as logging, metrics, dynamic configuration, RPC wiring, namespaces, and persistence glue that other parts reuse. The chasm directory defines the core data model and interfaces for typed components and archetypes used to build decoupled execution graphs. The schema directory embeds the schema filesystem and reads backend schema and visibility versions during database setup.

The codebase has 3,156 files and 40,520 symbols in 17 modules, led by Go, Shell and Makefile. Code health is 6.7 out of 10, rated fair.