Urbit / Docs
  1. Introduction
    1. Technical overview
      1. Source Code Overview
        1. Contributing
          1. Community Tutorials
            1. Arvo vs. Azimuth
            2. Getting Started
              1. Azimuth
                1. Landscape
                2. Learn
                  1. Arvo
                    1. Arvo Internals
                      1. Ames
                      2. Behn
                      3. Admin and Operations
                      4. Clay
                      5. Dill
                      6. Source layout
                      7. Sail
                      8. Messaging
                      9. Udon
                      10. Eyre
                      11. Gall Apps
                      12. Shell (Dojo)
                      13. Ford
                      14. Hall
                      15. Introduction to the Filesystem
                      16. Web (Eyre)
                      17. Generators
                    2. Hoon
                      1. Getting Started
                      2. Nouns
                      3. The Subject and Its Legs
                      4. Arms and Cores
                      5. Gates (Hoon Functions)
                      6. Multi-gate Cores and Doors
                      7. Hoon Programs
                      8. Hoon Syntax
                      9. Simple One-Gate Programs
                      10. Atoms, Auras, and Simple Cell Types
                      11. Type Checking and Type Inference
                      12. Structures and Complex Types
                      13. Cores
                      14. Cores Again
                      15. Standard Library: Lists
                      16. Standard Library: Trees, Sets, and Maps
                      17. Examples
                      18. Type Polymorphism
                    3. Nock
                      1. Nock Definition
                      2. Explanation
                      3. Example
                      4. Implementations
                    4. Vere
                      1. C Runtime System
                      2. C in Urbit
                      3. Land of Nouns
                      4. API overview by prefix
                      5. Writing Jets
                    5. Hoon Style Guide
                    6. Azimuth
                      1. Why Urbit Uses a Blockchain
                        1. The Urbit HD Wallet
                      2. Reference
                        1. Hoon Expressions
                          1. Runes
                            1. Atoms and strings
                            2. Nock . ("dot")
                            3. Wild ! ("zap")
                            4. Change Subject = ("tis")
                            5. Conditionals ? ("wut")
                            6. Cores | ("bar")
                            7. Arms + ("lus")
                            8. Cells : ("col")
                            9. Calls % ("cen")
                            10. Casts ^ ("ket")
                            11. Structures $ ("bus")
                            12. Make ; ("mic")
                            13. Hints ~ ("sig")
                            14. Terminators -- and ==
                          2. Limbs and Wings
                            1. Limbs
                            2. Wings
                          3. Basic Types
                            1. Advanced Types
                              1. Irregular forms
                              2. Standard library
                                1. 1a: Basic Arithmetic
                                  1. 1b: Tree Addressing
                                    1. 1c: Molds and Mold-Builders
                                      1. 2a: Unit Logic
                                        1. 2b: List Logic
                                          1. 2c: Bit Arithmetic
                                            1. 2d: Bit Logic
                                              1. 2e: Insecure Hashing
                                                1. 2f: Noun Ordering
                                                  1. 2g: Unsigned Powers
                                                    1. 2h: Set Logic
                                                      1. 2i: Map Logic
                                                        1. 2j: Jar and Jug Logic
                                                          1. 2k: Queue Logic
                                                            1. 2l: Container from Container
                                                              1. 2m: Container from Noun
                                                                1. 2n: Functional Hacks
                                                                  1. 2o: Normalizing Containers
                                                                    1. 2p: Serialization
                                                                      1. 2q: Molds and Mold-Builders
                                                                        1. 3a: Modular and Signed Ints
                                                                          1. 3b: Floating Point
                                                                            1. 3c: Urbit Time
                                                                              1. 3d: SHA Hash Family
                                                                                1. 3e: (Removed)
                                                                                  1. 3f: Scrambling
                                                                                    1. 3g: Molds and Mold-Builders
                                                                                      1. 4a: Exotic Bases
                                                                                        1. 4b: Text Processing
                                                                                          1. 4c: Tank Printer
                                                                                            1. 4d: Parsing (Tracing)
                                                                                              1. 4e: Parsing (Combinators)
                                                                                                1. 4f: Parsing (Rule-Builders)
                                                                                                  1. 4g: Parsing (Outside Caller)
                                                                                                    1. 4h: Parsing (ASCII Glyphs)
                                                                                                      1. 4i: Parsing (Useful Idioms)
                                                                                                        1. 4j: Parsing (Bases and Base Digits)
                                                                                                          1. 4k: Atom Printing
                                                                                                            1. 4l: Atom Parsing
                                                                                                              1. 4m: Formatting Functions
                                                                                                                1. 4n: Virtualization
                                                                                                                  1. 4o: Molds
                                                                                                                    1. 5a: Compiler Utilities
                                                                                                                      1. 5b: Macro Expansion
                                                                                                                        1. 5c: Compiler Backend & Prettyprinter
                                                                                                                          1. 5d: Compiler Backend & Prettyprinter
                                                                                                                            1. 5e: Caching Compiler
                                                                                                                              1. 5f: Molds and Mold-Builders
                                                                                                                                1. 5g: profiling support
                                                                                                                                  1. Zuse
                                                                                                                                  2. Glossary
                                                                                                                                    1. Cheat sheet
                                                                                                                                      1. Hoon Errors

                                                                                                                                      Introduction

                                                                                                                                      Welcome to the documentation for the Urbit project, including the Azimuth identity layer, the Arvo operating system, and the Hoon programming language. This documentation is maintained by Tlon in a public GitHub repository. Issues and contributions are welcome.

                                                                                                                                      The documentation is organized into four high-level sections. Read on to get acquainted.

                                                                                                                                      Introduction

                                                                                                                                      If you're looking for a high-level introduction to the Urbit project and its components, start here.

                                                                                                                                      Getting Started

                                                                                                                                      If you'd like to install Arvo, get an Azimuth point, and/or get on the Urbit network, you'll find guides here. Dive in, and don't be afraid to ask for help!

                                                                                                                                      Learn

                                                                                                                                      If you're interested in contributing to the project, building applications, or understanding the system technically, take a look at our tutorials and explanations of the Urbit components.

                                                                                                                                      Reference

                                                                                                                                      If you're a developer looking for Arvo reference documentation, this section is for you.

                                                                                                                                      • The Glossary will help if you're confused by all the new jargon.

                                                                                                                                      • The Cheat Sheet is a compact document for looking up Hoon expressions.