Introduction to Astral

Documentation / Introduction

The Future of Version Control

Astral (command: asl) is a next-generation version control system that fundamentally reimagines how developers interact with their code history. Built on principles of immutability, performance, and simplicity, it provides a cleaner, more intuitive interface while maintaining the reliability demanded by modern software development.

"Version control should be invisible. It should get out of your way and let you focus on what matters: writing code."

The Problem with Traditional VCS

Every developer has experienced the frustration. You're deep in a complex feature, juggling multiple dependent changes, and suddenly you're lost in a maze of branches, rebases, and merge conflicts. The tools meant to help you have become obstacles.

Traditional version control systems like Git were designed for a different era:

The staging area adds unnecessary cognitive overhead
Branch management becomes unwieldy at scale
SHA-1 hashing is both slow and cryptographically compromised
Graph-based history makes simple operations complex

Astral was born from the conviction that it doesn't have to be this way.

Why Astral Exists

⚡

Performance First

Operations remain instant regardless of repository size. Blake3 hashing and parallel processing ensure Astral scales with your project.

◇

Radical Simplicity

No staging area. No index. What you save is what you commit. The mental model is clean and predictable.

▣

Stack-Based Workflow

Dependent changes are a first-class concept. Build, reorder, and ship stacks of commits with ease.

◎

Enterprise Security

Built-in encryption, integrity verification, and lock-free concurrency for teams of any size.

Quick Comparison

Feature Matrix

Feature	Astral	Git
Hashing Algorithm	Blake3 (14 GB/s)	SHA-1 (1.5 GB/s)
Staging Area	None (Direct)	Required (Index)
Concurrency Model	Lock-free, Parallel	Single-threaded
Workflow Paradigm	Stack-based	Graph-based
Binary Size	< 5 MB	~50 MB

Core Philosophy

Astral is built on three foundational principles:

1. Content-Addressable Storage

Every piece of data is stored by its cryptographic hash. This means:

Deduplication happens automatically
Integrity is verified on every read
Immutability is guaranteed by design

2. Explicit Over Implicit

There's no hidden state. No "staging area" where changes might linger. When you save, you commit. When you commit, it's permanent.

# In Git, you do this:
git add .
git commit -m "My changes"

# In Astral, you do this:
asl save -m "My changes"

3. Stacks Over Branches

While Astral supports traditional branching, it encourages thinking in stacks of dependent changes. This maps more naturally to how code reviews work in modern development.