Radicle is a sovereign peer-to-peer network for code collaboration, built on top of Git.

Try it ↓

                _                                                _                                                     _                                                _                                                    _                                                _                                                
              (`  ).                   _                       (`  ).                   _                            (`  ).                   _                       (`  ).                   _                           (`  ).                   _                       (`  ).                   _                         
             (     ).              .:(`  )`.                  (     ).              .:(`  )`.                       (     ).              .:(`  )`.                  (     ).              .:(`  )`.                      (     ).              .:(`  )`.                  (     ).              .:(`  )`.                     
)           _(       '`.          :(   .    )                _(       '`.          :(   .    )                     _(       '`.          :(   .    )                _(       '`.          :(   .    )                    _(       '`.          :(   .    )                _(       '`.          :(   .    )                    
        .=(`(      .   )     .--  `.  (    ) )           .=(`(      .   )     .--  `.  (    ) )                .=(`(      .   )     .--  `.  (    ) )           .=(`(      .   )     .--  `.  (    ) )               .=(`(      .   )     .--  `.  (    ) )           .=(`(      .   )     .--  `.  (    ) )                   
       ((    (..__.:'-'   .+(   )   ` _`  ) )           ((    (..__.:'-'   .+(   )   ` _`  ) )                ((    (..__.:'-'   .+(   )   ` _`  ) )           ((    (..__.:'-'   .+(   )   ` _`  ) )               ((    (..__.:'-'   .+(   )   ` _`  ) )           ((    (..__.:'-'   .+(   )   ` _`  ) )                    
`.     `(       ) )       (   .  )     (   )  ._        `(       ) )       (   .  )     (   )  ._             `(       ) )       (   .  )     (   )  ._        `(       ) )       (   .  )     (   )  ._            `(       ) )       (   .  )     (   )  ._        `(       ) )       (   .  )     (   )  ._                 
  )      ` __.:'   )     (   (   ))     `-'.-(`  )        ` __.:'   )     (   (   ))     `-'.-(`  )             ` __.:'   )     (   (   ))     `-'.-(`  )        ` __.:'   )     (   (   ))     `-'.-(`  )            ` __.:'   )     (   (   ))     `-'.-(`  )        ` __.:'   )     (   (   ))     `-'.-(`  )               
)  )  ( )       --'       `- __.'         :(      ))   ( )       --'       `- __.'         :(      ))        ( )       --'       `- __.'         :(      ))   ( )       --'       `- __.'         :(      ))       ( )       --'       `- __.'         :(      ))   ( )       --'       `- __.'         :(      ))             
.-'  (_.'          .')                    `(    )  )) (_.'          .')                    `(    )  ))      (_.'          .')                    `(    )  )) (_.'          .')                    `(    )  ))     (_.'          .')                    `(    )  )) (_.'          .')                    `(    )  ))            
                  (_  )                     ` __.:'                (_  )                     ` __.:'                     (_  )                     ` __.:'                (_  )                     ` __.:'                    (_  )                     ` __.:'                (_  )                     ` __.:'              
                                                                                                                                                                                                                                                                                                                               

Peer-to-peer

Radicle enables users to run their own nodes, ensuring censorship-resistant code collaboration and fostering a resilient network without reliance on third-parties.

Secure

All social artifacts are stored in git, and signed using public-key cryptography. Radicle verifies the authenticity and authorship of all data automatically.

Local-first

Radicle is local-first, providing always-available functionality even without internet access. Users own their data, making migration, backup, and access easy both online and offline.

--'`,---..-.--+--.,,-,,..._.--..-._.---.--..,___.--,--'`,---..-.--+--.,,-,,..._.--..-._.---.--..,___.--,--'`,---..-.--+--.,,-,,..._.--..-._.---..,,-,,..._.--..-._.---.--..,___.--,--'`,---..-.--+--.,,-,,..._.--..-._.---.--..,___.--,--'`,---..-.--+--.,,-,,..._.--..-._.---.
┌╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴┐
┆  Radicle CLI                      ┆
└╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴┘
┌╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴┐
┆  Radicle Repository               ┆
┆ ┌────────┐ ┌────────┐ ┌─────────┐ ┆
┆ │  code  │ │ issues │ │ patches │ ┆
┆ └────────┘ └────────┘ └─────────┘ ┆
├╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴┤
┆  Radicle Storage                  ┆
└╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴┘
┌╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴┐
┆  Radicle Node                     ┆
┆ ┌────────────┐ ┌─────────────────┐┆
┆ │ Git Daemon │ │ Gossip protocol │┆
┆ └────────────┘ └─────────────────┘┆
└╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴┘

The Radicle Stack

Radicle functions as a peer-to-peer protocol where each user on the network runs identical software, known as the Radicle Stack. This stack primarily consists of a command line interface and a networked service called the Radicle Node.

Users can also opt to run the Radicle Web client and HTTP daemon, providing a familiar web-based experience for enhanced accessibility and convenience.

Browse the code →

The Radicle CLI

The Radicle CLI is a command line interface for the Radicle stack. It provides a suite of tools to interact with the Radicle network, including commands for managing issues, patches, and projects, as well as identity documents and profiles.

With the Radicle CLI, users can clone, checkout, and push projects to the network, manage patches and issues, and control and query the Radicle Node.

Try it ↓
$ rad init
 
Initializing radicle 👾 project in .
 
 Name: heartwood
 Description: Radicle Heartwood Protocol & Stack
 Project heartwood created
 
Your project id is rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji.
 
Show it at all times with:
    rad .
 
To publish your project to the network, run:
    git push
┌╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴┐          ┌╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴┐
┆┌─────────────────┐ ┌──────┐┆          ┆┌──────┐ ┌───────────────┐ ┆
┆│Storage          │ │      │┆   Git    ┆│      │ │Storage        │ ┆
┆│                 ├╸┆╸╸╸╸╸╸┆╸╸╸╸╸╸╸╸╸╸╸╸┆╸╸╸╸╸╸┆╸┤               │ ┆
┆│┌──────┐┌─────┐ ┌│ │      │┆ protocol ┆│      │ │┌─────┐┌─────┐ │ ┆
┆││repo  ││repo │ ││ │      │┆          ┆│      │ ││repo ││repo │ │ ┆
┆│├──────┤├─────┤ ├│ │      │┆          ┆│      │ │├─────┤├─────┤ │ ┆
┆└┴───╿──┴┴───┬─┴─┴┘ │      │┆          ┆│      │ └┴───┬─┴┴───╿─┴─┘ ┆
┆     │       │      │      │┆  gossip  ┆│      │      │      │     ┆
┆     │       │      │ Node ├╸╸╸╸╸╸╸╸╸╸╸╸┤ Node │      │      │     ┆
┆     │       │      │      │┆ protocol ┆│      │      │      │     ┆
┆    push    pull    │      │┆          ┆│      │     pull   push   ┆
┆     │       │      │      │┆          ┆│      │      │      │     ┆
┆     │       │      │      │┆          ┆│      │      │      │     ┆
┆     │       │      │      │┆          ┆│      │      │      │     ┆
┆┌────┴───┐┌──╽─────┐│      │┆          ┆│      │┌─────╽──┐┌──┴────┐┆
┆│working ││working ││      │┆          ┆│      ││working ││working│┆
┆│copy    ││copy    ││      │┆          ┆│      ││copy    ││copy   │┆
┆└────────┘└────────┘└──────┘┆          ┆└──────┘└────────┘└───────┘┆
└╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴┘          └╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴╴┘

How it Works

The Radicle network protocol focuses on locating, replicating, and verifying repositories in a peer-to-peer code hosting network. Its decentralized approach guarantees access to repositories, regardless of their location or replica count.

At the heart of Radicle is a gossip-based protocol for metadata exchange between nodes, which are identified by public keys. Nodes gossip repository information to build routing tables that aid in repository discovery and replication.

By leveraging Git, Radicle enables efficient data transfer and offers compatibility with existing workflows.

Learn more →

The Radicle Network

The Radicle Network is a peer-to-peer network that replicates code, issues and patches over the internet to create a resilient code collaboration system.

Radicle uses the Git protocol for data replication and its own gossip protocol to exchange peer and repository information between nodes.

Peer connections are established using the Noise protocol, which allows for secure, encrypted communications within the network.

                                          
           o       o                      
            \     /                       
         o   o   o     o   o   o          
          \ /    |    /     \ /           
           o     o - o       o - o        
           |    / \ /       /             
       o - o   o - o - o - o              
            \ / \ / \       \             
         o - o   o   o       o   o        
        /        \    \       \ /         
       o      o - o    o       o - o      
                 /                        
                o                         
~_~~~_~__~_--``--`-`-`-`~_~~-``-__~``-__~```-_~~~~_-__``__```~-`-`~_~~-``-__~``-__~```-_~~~-`-`~_~~-``-__~``-__~```-_~~~~_-__``__```~_~____~~_~_-__``__```~_~____~~__~____~~_~_~_~_~-`-`_~_~_~_~--~~~-~~-`~__~``-`_`*_~_~___*`-***_~_~_~_~_~~_-----__~*`_~```-_~~~~_-_

Try it Out

You can install Radicle by running the following command in your terminal.
Radicle is currently supported on Linux and macOS.

sh <(curl -sSf https://radicle.xyz/install)

Alternatively, you can build from source, or get the binaries.

( ) ( ) ( ) ( ) ( ) ( )
                                  \|/        
                                 --o--       
                                  /|\        
                                             
     *                     _                 
              _         =(_.                 
            -(__ .)    _(_ __)               
         . (_`     _)`-.                 .   
       =(         `  _) )                  * 
     (_( `             ' )                   
    ~.`._ ~__ _   .__ __'_-                  

Get Involved

Radicle is free and open source software licensed under the MIT and Apache 2.0 licenses. We welcome all contributors.

Check out our contributor guide and drop by Zulip to say hi.

The Radicle development team posts regular updates on Twitter. Follow us there to keep up to date.

..-.--*--.__-__..._.--..-._.---....~__..._.--..~._.---.--..____.--_--'`_---..
-.--~--._  __..._.--..~._.--- - -.____.--_--'`_---..~.----_~