Trying out Pijul

✍️ Written on 2022-07-26 in 2226 words.
Part of cs software-development

Update 2022-07-28: pneumier informed me that pijul is not line-based. I fixed this.


My first version control system was mercurial popular in the python community (at around 2008). Github became a big player soon (at around 2010) and I switched to git. I like git since it solves many problems neatly. However, the CLI is not intuitive. Fortunately they started to refactor the CLI with new subcommands like `restore. But in the end, you cannot ask non-technical people to use it. I don’t think Pijul solves this gap, but let us take a look. Pijul praises itself with a different three-way merge algorithm.

Getting started

  • You need to compile it yourself. Thus you need a rust toolchain. This is a caveat and I think pre-built binaries would be nice. I now assume you have the pijul executable available on your PATH.

  • cargo tree for libpijul shows 262 lines. Dependencies include chrono for timestamps, ed25519-dalek and others for cryptographic computations, diff for text difference computation, tokio for concurrency, ignore to consider .gitignore files, encoding_rs to handle text encodings, toml for TOML parsing, path-slash to support forward/backward slashes in paths, sanakirja (blogpost) for COW data structures, and so many more …

  • pijul uses three vocabularies:

    working copy

    the filesystem state, you modify


    difference between two states (changes between working copy and pristine can be listed with pijul diff)


    a set of files and folder tracked by Pijul (can be listed with pijul ls)


    representation of the current recorded version of the repository

  • A platform to store Pijul repositories and shows them in a web interface is provided at

  • Pijul repositories can be cloned via SSH or locally from folder to folder.

  • The negative connotation of git blame was renamed to pijul credit

The colorful output of ``pijul --help``

Generate keys

pijul identifies authors by their cryptographic key and not the (name, email address) tuple like git. I think their argument makes sense: if the identity is bound to the key, authors can change their name or email address later. The personal configuration on Linux is stored in ~/.config/pijul/config.toml. Key generation is required before any recording.

$ pijul key generate "Lukas Prokop"

Password for the new key (press enter to leave it unencrypted):
Wrote secret key in "/home/meisterluk/.config/pijul/secretkey.json"

$ head -n 5 /home/meisterluk/.config/pijul/secretkey.json
  "version": 0,
  "algorithm": "Ed25519",
  "encryption": {
    "Aes128": {

$ cat .config/pijul/config.toml

name = "meisterluk"
full_name = "Lukas Prokop"
email = "my@personal.mail"

Initialize project

$ pijul init

$ ls -la

totalo 4
drwxrwxr-x 1 meisterluk meisterluk 26 Jul 26 12:56 .
drwxrwxr-x 1 meisterluk meisterluk 26 Jul 26 12:56 ..
-rw-rw-r-- 1 meisterluk meisterluk 15 Jul 26 12:56 .ignore
drwxrwxr-x 1 meisterluk meisterluk 42 Jul 26 12:56 .pijul

$ find .


$ cat .pijul/config

record = []

$ cat .pijul/.ignore


So far, we have some empty pristine.

Record a change

Now let us add a default rust project to this folder and then let us create a patch with files Cargo.toml and src/ here:

$ pijul add Cargo.toml src/

$ pijul record
Password for "/home/meisterluk/.config/pijul/secretkey.json":
[opens the following file in $EDITOR]
message = ''
timestamp = '2022-07-26T11:13:48.386870872Z'

key = 'B1dSX4re8eF23y4jQaS3kRCc13eReajei91iX2XfawAj'

# Dependencies

# Hunks

1. File addition: "src" in "" +dx "binary"
  up 2.1, new 2:16

2. File addition: "" in "src" "UTF-8"
  up 0.1, new 65:96
+ fn main() {
+     println!("Hello, world!");
+ }

3. File addition: "Cargo.toml" in "" "UTF-8"
  up 2.1, new 277:311
+ [package]
+ name = "testproj"
+ version = "0.1.0"
+ edition = "2021"
+ # See more keys and their definitions at
+ [dependencies]

I just filled in the message, saved and closed the file to complete the record. And this is an actually interesting part: Whereas the content between # Dependencies and # Hunks will be ignored, the changes below # Hunks can be changed/discarded in-place. This makes it much easier than in git to split a larger commit into smaller ones.

Since this is now recorded, we can also see this change in the log:

$ pijul log

Author: Lukas Prokop
Date: 2022-07-26 11:13:48.386870872 UTC

    Initialize rust project

Date: 2022-07-26 11:13:52.490426426 UTC

Storing another change is so easy that I won’t show it: just edit the file and call pijul record.

Channels, not branches

However, channels are different from Git branches, and do not serve the same purpose. In Pijul, independent changes commute, which means that in many cases where branches are used in Git, there is no need to create a channel in Pijul.

The main differences with Git branches are:

  • The identity of a change doesn’t depend on the branch it is on, or in other words, rebase and merge are the same operation in Pijul.

  • This implies that conflicts do not mysteriously come back after you solve them (which is what git rerere is for).

  • Also, conflicts are between changes, so the resolution of a conflict on one channel solves the same conflict in all other channels.

Create channels with pijul fork <name> and list them with pijul channel. You can switch to another channel with pijul channel switch <channel>. If you want to remove a change, you can do so with pijul unrecord, but only if the change is on the current channel. And pijul apply <change> applies all changes until <change> onto the current channel. The documentation comment “all changes this change depends upon will be applied as well” shows that it does not work like git cherry-pick.

One of the main features of Pijul is that its internal representation of repositories fully models conflicts. Patches can even be applied to a conflicting repository, leaving the conflict resolution for later.

In order to create a conflict, I modified src/ in the same line on channel main and channel feature. Then I ran pijul apply <latest-change-from-feature-channel> in the main channel.


Outputting repository ↖

There were conflicts:

  - Order conflict in "src/" starting on line 2
  - Order conflict in "src/" starting on line 2

Inside src/, we can see the conflict:

fn main() {
>>>>>>> 1 [CGJNA7DH]
    println!("Change on main channel");
======= 1 [U5B4QNCA]
    println!("Text from feature branch");
<<<<<<< 1

Indeed. Even though the conflict is not resolved yet, we can see that the change was already applied:

$ pijul log

Author: Lukas Prokop
Date: 2022-07-26 18:07:02.414063222 UTC

    Change on feature branch

Author: Lukas Prokop
Date: 2022-07-26 18:07:54.529764850 UTC

    Change on main branch

Author: Lukas Prokop
Date: 2022-07-26 16:57:17.629465509 UTC

    My second record

Author: Lukas Prokop
Date: 2022-07-26 11:13:48.386870872 UTC

    Initialize rust project

Date: 2022-07-26 11:13:52.490426426 UTC

As you can see, the change has the same identifier on the feature channel as well as the main channel.

message = 'Conflict resolved'
timestamp = '2022-07-26T18:14:17.403138390Z'

key = 'B1dSX4re8eF23y4jQaS3kRCc13eReajei91iX2XfawAj'

# Dependencies

# Hunks

1. Replacement in "src/":2 4.49 "UTF-8"
B:BD 4.62 -> 2.0:40/2, B:BD 4.62 -> 3.0:42/3
  up 4.62, new 2:26, down 4.93
-     println!("Change on main channel");
-     println!("Text from feature branch");
+     println!("Merged");

The # Dependencies section seems to convey that different channels have been merged. [2] and [3] are the latest changes on the channels whereas [4] and [*] are the same and seem to indicate a merge (not sure how to read it).


  • I like that you can “select” the changes in the pijul record file.

  • I like that the distinction between rebasing and merging does not exist. This distinction means that “we are using git” can mean different things in two companies.

  • I like that identities are bound to some keyfile and not on the conventional (username, email address) tuple.

  • I am not sure about the merge algorithm (just because I didn’t think it through in detail). I only understand that it works with a rolling checksum, deletes are represented as special lines and merges are associative. This introductory blog post might help you.

  • Pijul needs more tools to visualize the progress of channels (similar to git log --graph).

All basic functionality worked flawlessly. The Nest must have been some large effort. Putting it into a large-scale test would yield important, heuristical results. I think this is a nice piece of software and I just need wider adoption of pijul to use it regularly.

As someone interesting in digital typesetting, I recognized that pmeunier is the lead of the Pijul development team. He was also involved in Patoline.