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. Type Polymorphism
                      18. Examples
                    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
                      1. Hoon Workbook
                        1. Caesar Cipher
                        2. Recursion
                        3. Digits
                        4. Magic 8-Ball
                        5. Traffic Light
                        6. Bomb Defusing
                    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

                                                                                                                                      5g: profiling support

                                                                                                                                      (To be documented)