# Build on Urbit

- [Contents](/build-on-urbit/contents.md): Overview of development resources for building on Urbit, including courses for learning Hoon, app development guides, core development, runtime development, and tools for Urbit developers.
- [Environment Setup](/build-on-urbit/environment.md): Developer environment setup guide for Urbit development, including text editor configuration, development ship setup, and project organization best practices.
- [Hoon School](/build-on-urbit/hoon-school.md): Beginner's course for learning Hoon, Urbit's functional programming language, with explanations, exercises, and tutorials for developers at all levels.
- [1. Hoon Syntax](/build-on-urbit/hoon-school/b-syntax.md): Introduction to Hoon programming language syntax, covering basic elements like nouns (atoms and cells), runes (operators), auras (atom types), and fundamental control flow structures.
- [2. Azimuth (Urbit ID)](/build-on-urbit/hoon-school/c-azimuth.md): Overview of Urbit ID (Azimuth) hierarchical address space, including galaxy, star, planet, moon, and comet identity types, their naming conventions, and sponsor relationships.
- [3. Gates (Functions)](/build-on-urbit/hoon-school/d-gates.md): Learn to create and use gates (functions) in Hoon, including deferred computations, type specification, file organization, generators, and irregular syntactic sugar forms.
- [4. Molds (Types)](/build-on-urbit/hoon-school/e-types.md): Guide to Hoon's type system, covering atoms with auras, molds for data structures, type-checking and type inference, core variance, nesting relationships, and type safety.
- [5. Cores](/build-on-urbit/hoon-school/f-cores.md): Introduction to cores, Hoon's fundamental data structure that separates computation from data. Covers traps for recursion, core creation with arms and samples.
- [6. Trees and Addressing](/build-on-urbit/hoon-school/g-trees.md): Understanding Urbit's binary tree data representation, tree addressing systems, data location and evaluation, the \`+list\` mold, and standard library operations for working with tree-structured data.
- [7. Libraries](/build-on-urbit/hoon-school/h-libraries.md): Guide to creating, importing, and using libraries in Hoon programming. Covers library imports with the /+ faslus rune, helper cores, composition runes, and best practices for code organization.
- [8. Testing Code](/build-on-urbit/hoon-school/i-testing.md): Testing Hoon code, including unit testing frameworks, fences for runtime assertions, debugging strategies, and best practices for building reliable and maintainable software.
- [9. Text Processing I](/build-on-urbit/hoon-school/j-stdlib-text.md): Introduction to text representation in Hoon, covering cords, tapes, knots, terms, text manipulation tools, and %say generators for command-line argument processing.
- [10. Cores and Doors](/build-on-urbit/hoon-school/k-doors.md): Advanced core concepts including doors (gate-building gates), doors as parametrized cores with sample data, working with \`+map\`s (key-value stores), and stateful computation patterns.
- [11. Data Structures](/build-on-urbit/hoon-school/l-struct.md): Guide to Hoon data structures including trees, sets, jars, and jugs. Covers mold builders, type system handling, compiler type checking, and practical manipulation operations.
- [12. Type Checking](/build-on-urbit/hoon-school/m-typecheck.md): Detailed examination of Hoon's type checking system, covering type casting, type inference, compile-time verification, mold application, and debugging nest-fail errors in complex type hierarchies.
- [13. Conditional Logic](/build-on-urbit/hoon-school/n-logic.md): Guide to conditional logic in Hoon, covering loobean (boolean) values, logical operators (AND, OR, NOT), conditional branching, switch statements, and pattern matching.
- [14. Subject-Oriented Programming](/build-on-urbit/hoon-school/o-subject.md): Guide to subject-oriented programming in Hoon, covering how expressions are evaluated within subjects, core composition, state management, deferred computations, and scrying local data.
- [15. Text Processing II](/build-on-urbit/hoon-school/p-stdlib-io.md): Advanced text processing in Hoon, covering text conversions, formatted text with $tanks, %ask generators, I/O operations, and practical tools for web data, JSON, and output formatting.
- [16. Functional Programming](/build-on-urbit/hoon-school/q-func.md): Functional programming concepts in Hoon, including gate manipulation, currying and binding samples, changing arity, function composition with cork and corl, and working with lists.
- [17. Text Processing III](/build-on-urbit/hoon-school/q2-parsing.md): Guide to text parsing in Hoon, covering parser fundamentals, rule building, parsing techniques with scanning and RegEx-like operations, and building complex parsers.
- [18. Generic and Variant Cores](/build-on-urbit/hoon-school/r-metals.md): Advanced core theory. Genericity with wet gates and cores, type polymorphism, dry vs wet core behavior, parametric polymorphism, and compile-time vs. runtime type-checking.
- [19. Mathematics](/build-on-urbit/hoon-school/s-math.md): Guide to mathematical operations in Hoon beyond unsigned integers, covering floating-point arithmetic, signed integers, modular arithmetic, bitwise operations, and IEEE 754.
- [App School I](/build-on-urbit/app-school.md): Guide to building Gall agents on Urbit.
- [1. Arvo](/build-on-urbit/app-school/1-arvo.md): Introduction to Arvo, Urbit's operating system and kernel.
- [2. The Agent Core](/build-on-urbit/app-school/2-agent.md): Guide to Gall agent structure and core concepts.
- [3. Imports and Aliases](/build-on-urbit/app-school/3-imports-and-aliases.md): Importing libraries, virtual arms, core composition, and boilerplate patterns.
- [4. Lifecycle](/build-on-urbit/app-school/4-lifecycle.md): Agent lifecycle management: state initialization, import and export, versioned state types, and upgrade procedures.
- [5. Cards](/build-on-urbit/app-school/5-cards.md): Gall agent effects, requests, responses, and subscription management.
- [6. Pokes](/build-on-urbit/app-school/6-pokes.md): Handling one-off messages (pokes) in Gall agents.
- [7. Structures and Marks](/build-on-urbit/app-school/7-sur-and-marks.md): Type definitions and data conversion for Gall agents.
- [8. Subscriptions](/build-on-urbit/app-school/8-subscriptions.md): Gall agent subscription management.
- [9. Vanes](/build-on-urbit/app-school/9-vanes.md): Guide to interacting with Arvo vanes (kernel modules) from Gall agents.
- [10. Scries](/build-on-urbit/app-school/10-scry.md): Guide to Gall agent scry functionality.
- [11. Failure](/build-on-urbit/app-school/11-fail.md): Guide to Gall agent error handling through the +on-fail arm and helper core patterns.
- [12. Next Steps](/build-on-urbit/app-school/12-next-steps.md): End of App School I.
- [Appendix: Types](/build-on-urbit/app-school/types.md): Explanation of types commonly used in Gall agents. Vase, mark, cage, quip, path, wire.
- [App School II (Full-Stack)](/build-on-urbit/app-school-full-stack.md): Walkthrough for building a full-stack Urbit application with a Gall backend and React frontend, demonstrating how to create complete web applications on Urbit.
- [1. Types](/build-on-urbit/app-school-full-stack/1-types.md): First step in building a full-stack Urbit app. Defining data structures in /sur files including basic types, action commands, update events, and state organization.
- [2. Agent](/build-on-urbit/app-school-full-stack/2-agent.md): Building the Gall agent backend for a full-stack app including imports, state management, poke handling, subscription patterns, and scry endpoints for data retrieval.
- [3. JSON](/build-on-urbit/app-school-full-stack/3-json.md): Building JSON conversion libraries for full-stack Urbit apps covering +enjs and +dejs functions for encoding/decoding data, mark conversion workflows, and bridging Gall agents with web frontends.
- [4. Marks](/build-on-urbit/app-school-full-stack/4-marks.md): Creating mark files for full-stack Urbit apps. Conversion methods between native types and JSON, defining +grow and +grab arms for custom type conversion logic.
- [5. Eyre](/build-on-urbit/app-school-full-stack/5-eyre.md): Using Eyre, the HTTP server vane, in full-stack Urbit development. Covers the channel system for pokes and subscriptions, scry interface for data queries, and authentication mechanisms.
- [6. React app setup](/build-on-urbit/app-school-full-stack/6-react-setup.md): Setting up React frontend for full-stack Urbit apps using the npm @urbit/create-landscape-app package, configuring @urbit/http-api for ship communication.
- [7. React app logic](/build-on-urbit/app-school-full-stack/7-app-logic.md): React application logic for full-stack Urbit apps covering state management, ship communication patterns, subscription handling, poke operations, and data synchronization.
- [8. Desk and glob](/build-on-urbit/app-school-full-stack/8-desk.md): Building and deploying full-stack Urbit apps including desk configuration, kelvin versions, docket file for app metadata, glob creation for frontend assets, and publishing for distribution.
- [9. Summary](/build-on-urbit/app-school-full-stack/9-final.md): Summary and conclusion of the full-stack Urbit app tutorial with reference links for all covered topics including types, agents, JSON conversion, marks, Eyre, React frontend, and desk publishing.
- [Core Academy](/build-on-urbit/core-academy.md): Course for developers who have finished Hoon School to learn Arvo kernel development, covering each part of Arvo, Zuse, Hoon, and the runtime for core Urbit OS development.
- [1. Evaluating Nock](/build-on-urbit/core-academy/ca00.md): Core Academy lesson on Nock evaluation covering all Nock rules 0-12, binary tree addressing, hints and jetting, scry operations, virtualized Nock with +mock, and the Urbit lifecycle function.
- [2. Building Hoon](/build-on-urbit/core-academy/ca01.md): Core Academy lesson on the Hoon compiler covering vase-mode programming with +slap/+slop algebra, the compilation pipeline from text to AST to Nock, type system mechanics, and Ford file building.
- [3. The Core Stack](/build-on-urbit/core-academy/ca02.md): Core Academy lesson on Urbit's core architecture. Subject-oriented programming, limb resolution mechanics, nested core structures, and the Hoon standard library organization.
- [4. Arvo I: The Main Sequence](/build-on-urbit/core-academy/ca03.md): Core Academy lesson on Arvo's event handling architecture covering the main sequence, moves and events, ducts and wires, vane interactions, scry operations, and Arvo's ACID transaction guarantees.
- [5. Arvo II: The Boot Sequence](/build-on-urbit/core-academy/ca04.md): Core Academy lesson on Arvo's boot sequence covering pill creation and loading, larval and adult phases, vane initialization, userspace bootstrapping, and the complete boot process.
- [6. Vere I: u3 and the Serf](/build-on-urbit/core-academy/ca05.md): Core Academy lesson on Vere runtime architecture covering the u3 noun system, king/serf processes, the Mars/Urth split, event log management, jet dashboard, and the Arvo/Vere interface.
- [7. Vere II: The Loom](/build-on-urbit/core-academy/ca06.md): Core Academy lesson on Vere's memory management covering the loom allocator, noun memory layout, reference counting, structural sharing, the road system, metacircularity, paging, and snapshots.
- [8. Vanes I: Behn, Dill, Kahn, Lick](/build-on-urbit/core-academy/ca07.md): Core Academy lesson on Arvo vanes covering the Behn timer vane, Dill terminal driver vane, Khan thread runner vane, Lick IPC vane.
- [9. Vanes II: Ames](/build-on-urbit/core-academy/ca08.md): Core Academy lesson on Ames covering the encrypted peer-to-peer protocol, its packet structure, message flows, cryptographic operations, integration with Urbit ID, and the Fine remote scry protocol.
- [10. Vanes III: Eyre, Iris](/build-on-urbit/core-academy/ca09.md): Core Academy lesson on HTTP vanes covering the Eyre vane's HTTP server functionality, the Iris vane's HTTP client operations, web request/response patterns and authentication mechanisms.
- [11. Vanes IV: Clay](/build-on-urbit/core-academy/ca10.md): Description of Clay, Arvo's revision-controlled filesystem vane. Also covers the build system, marks, scry cares, %kiln.
- [12. Vanes V: Gall and Userspace](/build-on-urbit/core-academy/ca11.md): Covers Gall, Arvo's userspace application framework vane, the agent type, running agents, and userspace software updates.
- [13. Vanes VI: Khan, Lick](/build-on-urbit/core-academy/ca12.md): This lesson covers I/O with Khan, Arvo's thread runner vane, and Lick, Arvo's IPC vane.
- [14. Vanes VII: Jael, Azimuth](/build-on-urbit/core-academy/ca13.md): A look at Urbit's networking key infrastructure. Covers the Jael vane, the %eth-watcher agent, and Azimuth's Layer 2 rollup solution.
- [Runtime](/build-on-urbit/runtime.md): Documentation for Urbit's runtime and Nock interpreter (Vere), including guides for U3, jetting, C programming in Urbit, and cryptography implementation.
- [U3](/build-on-urbit/runtime/u3.md): Introduction to u3, the Nock runtime system. C library for making and storing nouns. Solid-state interpreter.
- [Conn.c Guide](/build-on-urbit/runtime/conn.md): Guide for using conn.c driver. Unix domain socket for external ship interaction. Khan vane, urbit eval utility.
- [How to Write a Jet](/build-on-urbit/runtime/jetting.md): Complete tutorial on writing jets in Urbit. C implementations of Hoon gates for performance. Developer environment setup.
- [API Overview by Prefix](/build-on-urbit/runtime/api.md): API overview by prefix for u3 system modules. Function reference for noun manipulation, jets, allocation, Nock computation.
- [C in Urbit](/build-on-urbit/runtime/c.md): C conventions and style used in Urbit. Integer types, variable naming, loobeans. The c3 layer under u3.
- [Cryptography](/build-on-urbit/runtime/cryptography.md): Cryptographic primitives used by Arvo. Ed25519 signatures, AES-SIV encryption. All jetted for performance.
- [Land of Nouns](/build-on-urbit/runtime/nouns.md): Comprehensive guide to u3 noun processing in C. Memory model, reference counting, road system architecture.
- [Tools](/build-on-urbit/tools.md): Developer documentation for additional tools, external libraries, and third-party applications for Urbit development, including JavaScript libraries and documentation tools.
- [Useful Links](/build-on-urbit/tools/links.md): Curated collection of external Urbit development resources including app repositories, Hoon libraries, JavaScript packages, documentation sites, and development tools.
- [JS Libraries](/build-on-urbit/tools/js-libs.md): JavaScript libraries for Urbit development including @urbit/http-api for communicating with a Gall agent backend from a React web frontend.
- [HTTP API](/build-on-urbit/tools/js-libs/http-api-guide.md): Guide to the @urbit/http-api JavaScript library for building web frontends that communicate with Urbit ships, covering authentication, pokes, subscriptions, scries, threads, and practical examples.
- [Docs App](/build-on-urbit/tools/docs-app.md): Documentation application for distributing docs with Urbit desks.
- [File Format](/build-on-urbit/tools/docs-app/file-format.md): File format specifications for the %docs app including %docu mark requirements, supported formats (udon, txt, html, gmi), syntax rules, and conversion guidelines for documentation publishing.
- [Index File](/build-on-urbit/tools/docs-app/index-file.md): Configuration guide for doc.toc index files in the %docs app, covering structure definition, hierarchical organization, file/directory specification, and automatic table of contents generation.
- [Suggested Structure](/build-on-urbit/tools/docs-app/structure.md): Best practices for organizing documentation in the %docs app, covering user documentation, developer API references, changelog structure, and data type documentation patterns.
- [Userspace](/build-on-urbit/userspace.md): Guides for building and distributing userspace applications on Urbit, including examples, exercises, and tutorials for app development.
- [Command-Line App Tutorial](/build-on-urbit/userspace/cli-tutorial.md): Complete tutorial for building CLI applications using /lib/shoe.hoon. Command parsing, session management, the %shoe example app.
- [Remote Scry](/build-on-urbit/userspace/remote-scry.md): Remote scrying between ships since kernel v413. Publishing with %grow, encryption options, access control, %keen/%chum/%tune lifecycle.
- [Unit Tests](/build-on-urbit/userspace/unit-tests.md): Unit testing framework using -test thread and /lib/test.hoon. Write test arms with +test-\* pattern that return $tang.
- [Software Distribution](/build-on-urbit/userspace/dist.md): Urbit supports peer-to-peer distribution and installation of applications. A user can click on a link to an app published on another ship to install.
- [Software Distribution Guide](/build-on-urbit/userspace/dist/software-distribution.md): Complete tutorial for creating and publishing Urbit apps. Walk through Hello World example from desk creation to remote installation via Treaty.
- [Docket File](/build-on-urbit/userspace/dist/docket.md): Docket file configuration for Landscape apps. Defines tile appearance, glob source, version, and metadata using clauses like %title, %color.
- [Glob](/build-on-urbit/userspace/dist/glob.md): Globs contain client-side resources (HTML, JS, CSS) for Landscape apps. Distribution over Ames or HTTP, Globulator tool, make-glob thread.
- [Examples](/build-on-urbit/userspace/examples.md): Examples and exercises for building Urbit userspace apps including CLI tools, websites, and games.
- [Building a CLI App](/build-on-urbit/userspace/examples/rpn.md): Tutorial on building a reverse Polish notation calculator CLI app using Hoon and the shoe library.
- [Debugging Wrapper](/build-on-urbit/userspace/examples/dbug.md): Guide to using the dbug library to debug Gall agents and inspect their state.
- [Host a Website](/build-on-urbit/userspace/examples/feature.md): Tutorial on building a simple website hosting app using the Schooner library to serve HTML pages from Urbit.
- [Serving a JS Game](/build-on-urbit/userspace/examples/flap.md): Tutorial on connecting a JavaScript Flappy Bird game to an Urbit backend with leaderboard and file serving.
- [Ship Monitoring](/build-on-urbit/userspace/examples/ahoy.md): Tutorial on building a ship monitoring app with Sail frontend, CLI generators, and Behn timers for notifications.
- [Styled Text](/build-on-urbit/userspace/examples/track7.md): Tutorial on producing styled text with styx strings and outputting them from Urbit agents to the terminal.