git.iko.soy/urbit.org
on master help sign in
Merge branch 'master' of https://github.com/urbit/urbit.org
commitef55d3e5b42981529e33a5b6367afd96c550184b authorRobert <robert@tlon.io> dateThu 19 Mar 2020, 17:15 (7 years ago) parent29163ec5f92d54
53 files changed+8336−1629
compare with master
unifiedsplit
content/blog/beliefs-and-principles.md+2−1 content/blog/creating-sigils.md+170 content/blog/interim-constitution.md+1−1 content/blog/landscape-a-portrait.md−1 content/blog/precepts-discussion.md+768 content/blog/precepts.md+355 content/understanding-urbit/simple-durable-yours.md → content/blog/simple-durable-yours.md+2−5 content/blog/the-dao-as-a-lesson-in-decentralized-governance.md+1−1 content/blog/urbit-for-normies.md+177 content/understanding-urbit/your-last-computer.md → content/blog/your-last-computer.md+2−5 content/community/governance.md+2−3 content/community/hoonschool.md+1−1 content/community/hosting-a-meetup.md+7−9 content/community/meetups.md+3−1 content/docs+1−1 content/faq.md+15−11 content/understanding-urbit/interface.md+63 content/understanding-urbit/network-and-os.md−40 content/understanding-urbit/people-history.md+104 content/understanding-urbit/project-history.md−79 content/understanding-urbit/roadmap.md+80 content/understanding-urbit/technical-overview.md−47 content/understanding-urbit/urbit-id.md+30−37 content/understanding-urbit/urbit-os.md+58 content/updates/2019-11-06-update.md+11−11 content/updates/2019-12-06-update.md+8−8 content/updates/2020-02-06-update.md+41 content/using/develop.md+2−2 content/using/install.md+16−7 content/using/operations/using-bridge.md+6−4 content/using/operations/using-your-ship.md+37 sass/_main.scss+66−25 static/glossary.js+5737 static/runes.js−982 static/scripts.js+99−87 templates/base.html+1−1 templates/essays/list.html+21−16 templates/essays/post.html+5−4 templates/index.html+88−98 templates/list.html+4−4 templates/media/list.html+19−17 templates/page.html+5−2 templates/page_indiced.html+2−2 templates/partials/footer.html+2−2 templates/partials/navigation-docs.html+56−5 templates/partials/navigation-search.html+28−3 templates/partials/pagination.html+14−14 templates/partials/search-overlay.html+2−2 templates/sections/docs/glossary.html+57 templates/sections/docs/hoon.html+52 templates/understanding-urbit/list.html+73−79 templates/understanding-urbit/post.html+37−3 templates/updates/list.html+5−8
content/blog/beliefs-and-principles.md+2−1
@@ -2,7 +2,8 @@
22title = "Beliefs and principles guiding the Urbit project."
33date = 2016-05-11
44description = "We believe."
5−aliases = ["/posts/essays/beliefs-and-principles", "/posts/beliefs-and-principles"]
5+aliases = ["/posts/essays/beliefs-and-principles",
6+"/posts/beliefs-and-principles", "/posts/principles"]
67[extra]
78author = "Curtis Yarvin + Galen Wolfe-Pauly"
89ship = "~sorreg-namtyv + ~ravmel-ropdyl"
content/blog/creating-sigils.mdnew file+170
@@ -0,0 +1,170 @@
1++++
2+title = "Creating Sigils"
3+date = 2020-02-04
4+description = "The origin and design process informing Urbit's generative user avatar system, Sigils."
5+[extra]
6+author = "Gavin Atkinson"
7+ship = "~ridlur-figbud"
8+image ="https://media.urbit.org/site/posts/essays/sigils3.png"
9++++
10+
11+<!-- ![](https://media.urbit.org/site/blog-9.jpg) -->
12+![](https://media.urbit.org/site/posts/essays/sigils0-v3.png)
13+
14+One of the basic building blocks of Urbit is Urbit ID, our naming and identity system. Your Urbit ID is a short, recognizable name that’s also a network address for your Urbit OS instance. (You can find a complete, high level description of Urbit ID [here](https://urbit.org/understanding-urbit/urbit-id/).)
15+
16+Your Urbit ID is meant to feel a bit like a secret code name. It doesn’t leak any information about the real you — but it’s still memorable and recognizable. Getting an Urbit ID should feel exciting, like getting a brand new identity in a new world.
17+
18+From a design standpoint, some of this is accomplished simply by having a system for the names themselves. Under the hood, Urbit IDs are actually just numbers. There has always been an algorithm for turning these numbers into pronounceable names like `~tacryt-socryp` (13,304,832) or `~litzod` (1,280) or `~nes` (212).
19+
20+While the names are great, they’re not quite enough, especially in a rich interface. Each Urbit ID really needed some form of visual representation, image, or crest. A digital identity needs to be something you can really attach to, both yours and those that belong to your friends.
21+
22+There are 2<sup>32</sup> or 4.2 billion unique Urbit IDs. Clearly there’s no way that we were going to do this by hand. And purely algorithmic solutions can often produce disappointing, undifferentiated output.
23+
24+Regardless, we set out to tackle this problem. By the end of this process, every Urbit ID got its very own ‘sigil.’
25+
26+In this post we’ll walk through how we thought about the problem, iterated through possible solutions, and the toolchain we used to arrive at the final result.
27+
28+## Background
29+
30+What are the basic primitives of a visual language? There aren’t any completely authoritative answers to this question, of course. But we knew that to produce such a large number of visually distinct items we’d need some way to reason about form that’s closer to letterforms.
31+
32+So we started by collecting influences.
33+
34+<iframe class="arena-iframe" width="100%" src="https://www.are.na/tlon/seal-zp3irwad52y/embed"></iframe>
35+
36+The ‘chop’ or [seal](https://en.wikipedia.org/wiki/Seal_(East_Asia)) is conceptually pretty close to what we wanted to get to.
37+
38+<br /><br />
39+
40+<iframe class="arena-iframe" width="100%" src="https://www.are.na/tlon/kamon/embed"></iframe>
41+
42+[Kamon](https://en.wikipedia.org/wiki/Mon_(emblem)) are even closer — especially since they have very little visual complexity.
43+
44+<br /><br />
45+
46+<iframe class="arena-iframe" width="100%" src="https://www.are.na/tlon/grids-jd_xbmspxkm/embed"></iframe>
47+
48+We also spent a good amount of time with both Anni Albers and Agnes Martin. Both of these painters had an incredible mastery of the grid as a means of creating engaging visual work. These paintings all have a wonderful tension between an underlying system and their specific expression.
49+
50+<br /><br />
51+
52+<iframe class="arena-iframe" width="100%" src="https://www.are.na/tlon/stella-xfroicotm_4/embed"></iframe>
53+
54+Frank Stella is a master at producing incredibly dynamic work from only a few elements. His ability to create a sense of depth from simple overlapping elements is fantastic.
55+
56+<br /><br />
57+
58+<iframe class="arena-iframe" width="100%" src="https://www.are.na/tlon/ledoux-palladio/embed"></iframe>
59+
60+The plans of both Ledoux and Palladio are incredibly dynamic. They’re mostly gridded, use only a few elements, and use lots of symmetry — but they’re at once distinct, engaging, and fresh.
61+
62+<br /><br />
63+
64+<iframe class="arena-iframe" width="100%" src="https://www.are.na/tlon/flags-k9moxiayuvq/embed"></iframe>
65+
66+Another influence: international maritime signal flags. We like these not only because of their striking visual qualities, but also because they correspond with a letter system, just like our sigils. Each one conveys useful information; for example, “Keep clear of me; I am maneuvering with difficulty,” a flag we all feel like raising from time to time. This influence was key to the idea that pairing symbol to phoneme was a possibility.
67+
68+You can see the whole collection of our visual research [here](https://www.are.na/tlon/2019-sigils-research).
69+
70+Ultimately, we didn’t specifically draw on any of these influences very consciously. The goal of visual research is to get a sense of the territory, what has been tried, and what works. We think these threads of prior work are evident in the final result — you can *feel* them, but it’s tough to point to them individually.
71+
72+## What’s in a name?
73+
74+> *“Lev’s sigil appeared, strobing, as Netherton was getting out of the cab in Henrietta Street. “Yes?” Netherton asked.”*
75+>
76+> <cite>— William Gibson, The Peripheral</cite>
77+
78+Before we get to how we worked through the problem of actually designing these things, let’s talk about the problem of naming.
79+
80+We went through so many names for these things. Crest, symbol, seal, tag, pictograph, stamp, emblem, signet, icon, glyph, holomark, visage, radigy, pattern, the list goes on for an incredibly (embarrassingly) long time. We argued about this, we went back and forth about it.
81+
82+Sigil won, ultimately, because of the way that it’s personified in William Gibson’s *The Peripheral*. In the far future, characters talk to each other by some kind of telepresence. When a call comes in from someone else, they first appear as a ‘sigil.’ It’s a strange word, but we were imagining a similar use-case.
83+
84+While we can’t point to any specific parts of our visual research that reappear directly, sigil is lovingly borrowed.
85+
86+## Experiments + iterations
87+
88+So, how did we actually end up making these things?
89+
90+We iterated through plenty of possibilities before landing on our final approach. Let’s walk through the two we remember best.
91+
92+<br /><br />
93+
94+![](https://media.urbit.org/site/posts/essays/sigils1-v2.png)
95+
96+The first attempt was a series of images in the style of Karel Martens. Overall this technique was just too cluttered and sometimes difficult to parameterize in a predictable way. We kept iterating.
97+
98+<br /><br />
99+
100+![](https://media.urbit.org/site/posts/essays/sigils2-v2.png)
101+
102+Just like the previous example, the main idea was that we could take a set of geometric primitives, combine them, then alter their appearance along a set of parameters, like color, rotation, and size.
103+
104+But also just like the previous attempt, the technique of overlapping symbols made the images too difficult to read and differentiate. We wanted to create sigils that were not only great to look at, but visually ordered. Since overlapping elements didn’t seem to quite hit the mark, on we went.
105+
106+## Closing in
107+
108+Eventually, we realized: tiles! With tile designs there are no overlaps, which in early experiments immediately started to take on the consistent, legible appearance we were after. Each element is discrete and clearly visible. Tile designs were also easier to create and control from an implementation standpoint.
109+
110+Best of all, tiles made it clear that we should be thinking in terms of creating representations of individual syllables rather than entire names. Urbit IDs are constructed from two sets of 256 three-letter syllables. `~fallyn-balfus` is `fal` `lyn` `bal` `fus`, for example. (There are two syllable sets in order to prevent duplicates — we always alternate between the two when composing names.)
111+
112+Thinking in terms of syllables greatly reduced the complexity of the problem, but there was still some work to do.
113+
114+<br /><br />
115+
116+![](https://media.urbit.org/site/posts/essays/sigils3-v2.png)
117+
118+At first, we thought about using a 4 x 4 tile grid, as shown here. These designs were tricky to implement because of the detailed lines and arcs spanning across individual tiles. In order to generate a result that matched these mockups, a program would have to generate a data model that knew about which tiles touched which other tiles.
119+
120+We felt this was too complicated and had an unknown performance profile. Plus, they proposed a deterministic color scheme and we felt strongly that color is personal, not to mention hard to parameterize. In the end we thought it better to create something that had the potential for user customization.
121+
122+<br /><br />
123+
124+![](https://media.urbit.org/site/posts/essays/sigils4-v2.png)
125+
126+Around this stage, we were thinking a lot about how architectural plans aren’t unduly constrained by the fact that they’re only one color. We had a feeling we could make the grid smaller and assign details to the tiles individually.
127+
128+<br /><br />
129+
130+![](https://media.urbit.org/site/posts/essays/sigils10-v3.png)
131+
132+So, we scaled it down to a 2 x 2 grid and stuck with it. It’s simple to implement, visually unique, consistent, and the color scheme is black and white, leaving room for user customization. We felt we had reached a semblance of a final result. Now all we had to do was manually draw 512 unique but consistent individual ‘phonemes’.
133+
134+<br /><br />
135+
136+![](https://media.urbit.org/site/posts/essays/sigils5-v2.png)
137+
138+As it turns out, drawing 512 consistent, abstract elements by hand isn’t easy. We had to strike a balance between authorship and automation — we wanted each tile to look well-made, but not too authored. To do so, we took advantage of Figma’s web API which helped us design in SVG but iterate programmatically.
139+
140+## Final process
141+
142+![](https://media.urbit.org/site/posts/essays/sigils6-v4.png)
143+
144+We took a look at our hand drawn mockups and drew each individual visual building block of the tiles separately. Then we loaded the SVG elements into a script that programmatically combined them to create trillions of layered symbols. This way, we were able to easily select candidate phoneme symbols that worked visually.
145+
146+We eventually added a rule system to find higher quality phoneme symbols — but this combination of programmatic generation and hand selection was working pretty well.
147+
148+<br /><br />
149+
150+![](https://media.urbit.org/site/posts/essays/sigils7-v2.png)
151+
152+The final step, using the tool we built, was to hand select individual phoneme symbols and create a complete index.
153+
154+<br /><br />
155+
156+![](https://media.urbit.org/site/posts/essays/sigils8-square-v2.png)
157+
158+This allowed us to start looking at possible combinations and selecting phoneme symbols based on their interplay with others.
159+
160+Once we had selected the final set, we went about compiling the `sigil-js` library that’s now publicly available. This turned out to be fairly technically complex due to the different ways SVG is handled between browsers and Figma — but the end result is a single Javascript library you can use to embed an SVG in almost any context on a web page. See it in action and browse the available sigils [here](https://sigil.azimuth.network). If you're technically inclined, the [source](https://github.com/urbit/sigil-js) can be found on Github.
161+
162+<br /><br />
163+
164+![](https://media.urbit.org/site/posts/essays/sigils9.png)
165+
166+We think sigils are pretty successful. They look nice in our native Urbit interfaces, people have made them into shirts and posters and cards, even laser-cut them to make stamps.
167+
168+Urbit ID and the sigils are components of Urbit that are totally separate from the OS — you can use them on their own and potentially even extend their functionality. We’re happy with what we’ve done with them so far, and hope that people will experiment with what’s possible with this naming and identity system.
169+
170+![](https://media.urbit.org/site/posts/essays/sigils11-v2.png)
content/blog/interim-constitution.md+1−1
@@ -2,7 +2,7 @@
22title = "Interim Constitution"
33date = 2016-05-16
44description = "The governing rules for the early days of the Urbit network."
5−aliases = ["/posts/essays/interim-constitution", "/posts/interim-constitution"]
5+aliases = ["/posts/essays/interim-constitution", "/posts/constitution"]
66[extra]
77author = "Tlon"
88ship = ""
content/blog/landscape-a-portrait.md−1
@@ -6,7 +6,6 @@ aliases = ["/posts/essays/landscape-a-portrait/", "/posts/landscape-a-portrait"]
66[extra]
77author = "Matilde Park"
88ship = "~haddef-sigwen"
9−image = "https://media.urbit.org/site/posts/essays/landscape-a-portrait-1.png"
109+++
1110
1211![](https://media.urbit.org/site/posts/essays/landscape-a-portrait-1.png)
content/blog/precepts-discussion.mdnew file+768
@@ -0,0 +1,768 @@
1++++
2+title = "Precepts: Discussion"
3+date = 2020-03-18
4+description = "The precepts aren’t arguments. We discuss and justify them here."
5+[extra]
6+author = "Philip Monk"
7+ship = "~wicdev-wisryt"
8+image ="https://media.urbit.org/site/posts/essays/discuss-01.jpg"
9++++
10+
11+<br>
12+
13+<img class="ba" src="https://media.urbit.org/site/posts/essays/discuss-01.jpg">
14+
15+The precepts aren’t arguments. We will discuss and justify them here. We don't expect to convince you this is exactly the right set of precepts, but we hope to convince you that this is a coherent set of precepts that might lead to something very interesting.
16+
17+We will address these in the same categories presented above:
18+
19+- A: General Design. Principles of engineering that apply in a great
20+ many situations. Any piece of code will exhibit at least a few of
21+ these.
22+
23+- B: Specific Design. principles of engineering that apply in a few
24+ specific situations. What these lack in general applicability they
25+ make up in specific guidance.
26+
27+- C: Attitude. Good code is the result of people approaching the act of
28+ engineering with the right attitude.
29+
30+- D: Theory. The eternal tension between theory and practice must not
31+ simply be acknowledged but dealt with.
32+
33+- E: Text Style. Code form matters.
34+
35+- F: Real Software. Not all software matters. Any software which
36+ wouldn't exist on Mars isn't real.
37+
38+<br>
39+
40+<img class="ba" src="https://media.urbit.org/site/posts/essays/discuss-02.jpg">
41+
42+### A: General Design
43+
44+These are principles of engineering that apply in a great many
45+situations. Any significant piece of code will exhibit at least a few
46+of these.
47+
48+### Simplicity
49+
50+> A20: One hundred lines of simplicity is better than twenty lines of
51+> complexity.
52+
53+> A21: Prefer mechanical simplicity to mathematical simplicity.
54+
55+At Urbit's root is a strong opinion on what constitutes simplicity. We take a semi-subjective view of simplicity. Specifically, we say that the sort of simplicity that matters is the sort that makes it easy to reason about stuff. We call this "mechanical simplicity".
56+
57+A competing view of simplicity says that it can be measured objectively by metrics such as the number of moving parts, the number of kinds of moving parts, the orthogonality of concepts, or cyclomatic complexity. We believe these are important metrics because they are good approximations of mechanical simplicity, but they don't tell the whole story.
58+
59+In acoustics, we use decibels of sound pressure to measure objective volume of sound. However, the Fletcher-Munson curves (equal-loudness contours) describe how loud sounds are perceived to be relative to their frequency. For example, a 75 dB sound at 4kHz sounds equally loud to a 90 dB sound at 10 kHz, even though the latter is over 20 times the sound pressure.
60+
61+Similarly, some sorts of complexity are much easier for humans to deal with than others. For example, humans are much better at learning languages compared to even simple mathematics. Even those who are "good at math" are objectively much better at languages, in terms of how much complexity they can absorb. Humans are also built to understand some
62+social dynamics and structures, even very complex and nuanced ones, without even consciously knowing the rules to them.
63+
64+Some examples of things that are objectively quite simple but subjectively hard for people to learn:
65+
66+- Pointers. Once you've properly learned them, it becomes hard to
67+ sympathize with your past self that found them difficult, but in
68+ practice these are a stumbling block for many people. Some think
69+ they're a "weed-out" concept, meaning they're just a good litmus test
70+ to see if you're the type of person who can learn how to program.
71+ Even if that's the case, it's still meaningful that they're effective
72+ in that.
73+
74+- Recursion. Same as above. Notably, `while` loops do not evoke the
75+ same reactions in people.
76+
77+- Monads. A little more complicated than the above, but objectively not
78+ that complicated. Certainly much less complicated than the C++
79+ standard library, but for some reason many people fail to learn monads
80+ after giving it an honest attempt, while that's rarely the case for
81+ the C++ standard library.
82+
83+- Math in general. The ideas in mathematics are generally pretty clean
84+ and small, which is why once you've learned a concept, it seems
85+ obvious in retrospect. The C++ standard library doesn't look much
86+ more obvious in retrospect than it does on first glance.
87+
88+- Any language that induces a moment where you exclaim to yourself,
89+ "This is true programming! Everyone should program this way, it's so
90+ obviously better!". People say that often about Lisp, Haskell,
91+ Prolog, and Smalltalk. Nobody ever said that about C, Java,
92+ Javascript, or Python. And yet, which ones are easier to learn?
93+ Which ones are used in real life?
94+
95+I've emphasized learning here, but the same principles apply to using a
96+tool after you've learned it.
97+
98+When evaluating simplicity, presumption should be on the side of "what
99+everybody does when they have a choice" instead of "what's
100+mathematically simpler". Being mathematically simple is a point in your
101+favor, but the burden of proof still falls on you to argue that it will
102+be simpler to learn and use.
103+
104+Adherence to this precept is difficult because you have to decide
105+whether an objectively simpler construction is in fact better. This
106+gives a framework for deciding the question.
107+
108+> A19: Dualities must be faced head-on and analyzed differently at
109+> different layers.
110+
111+A crucial point is that the question of simplicity depends on the facts
112+and circumstances of the case. In deeper layers of the system,
113+mathematical simplicity tends to pay greater dividends. If the features
114+of the base layer are not orthogonal, the interactions between them will
115+only grow more complex as you rise in the stack. If the base layer has
116+many moving parts, the number of moving parts can only increase as you
117+rise in the stack.
118+
119+This isn't the only duality that depends on the layer of the stack.
120+The most important layering of the stack is between "systems" and
121+"applications", where "applications" are those pieces of code on which
122+no other application depends. Many answers that are correct in system
123+code are incorrect in application code, and vice versa. These precepts
124+are an attempt to describe principles that apply at all areas of code,
125+but they're much more important to follow in system code.
126+
127+> A22: The Law of Leaky Abstractions is a lie; abstract airtightly.
128+
129+The Law of Leaky Abstractions says that all non-trivial abstractions are
130+leaky. This is the sort of statement that most engineers will accept
131+immediately and most mathematicians would dismiss out-of-hand. In
132+mathematics, if an abstraction leaks, it's not simply an imperfect
133+abstraction, it's completely wrong and should be thrown away. So they
134+manage to create perfect abstractions. They don't always abstract what
135+you wanted to abstract, but at least they're perfect.
136+
137+If mathematicians can do that, there's no reason programmers shouldn't
138+be able to do it as well. Sure, programmers have to deal with some
139+performance considerations that mathematicians can elide, but that's
140+rarely the reason abstractions leak. They leak most often because the
141+creators are lazy or sloppy. If your abstraction leaks, find a way to
142+either plug the leak or reframe the abstraction to incorporate the
143+"leak" in a coherent way. It's not a leak if it's part of the spec. I
144+call this "turning leaks into decorative fountains".
145+
146+### Conceptual clarity
147+
148+> A6: Represent your data as closely as possible to the essential
149+> structure of the problem.
150+
151+There are times when you need to represent your data in an unnatural
152+format for performance reasons, but this is rare. When possible, keep
153+the structure and location of your data in as natural of a manner as
154+possible. For example, if a function can produce an integer or an
155+error, don't produce a negative number to indicate an error — use an
156+explicit tagged union.
157+
158+An important part of this is to fit your data types to your data
159+skin-tightly. If your data types permit states that you intend to be
160+impossible, this is suboptimal. There are degrees of this (if you need
161+a number between 0 and 1000, a uint32 is probably fine even though it's
162+suboptimal), but it's important to strive for it.
163+
164+As an example, if your program can't respond to requests until it
165+completes an initialization process to fill in some of its state, it's
166+tempting to make nullable all the parts of its state that are filled in
167+during the initialization process, then just check whether they're
168+nullable when you use them. This creates a complex set of representable
169+states of partial initialization, and any bugs in that area will be
170+difficult to track down. A better option is to create a "larval" stage
171+of your program that performs the initialization. If requests come in
172+during this larval stage, queue them up until it's done. When it finishes
173+initialization, it metamorphizes into the full program, where all the
174+fields in its state are not nullable. Then run through its queue of
175+pending requests. This more closely resembles the essential structure
176+of the problem.
177+
178+> A8: When mating different paradigms, build one cleanly on top of the
179+> other.
180+>
181+> A9: Never misuse an abstraction.
182+
183+An abstraction provides a set of tools to solve a problem. Use them in
184+the intended way. If this is awkward, consider that this may be the
185+wrong abstraction to use. If the impedance mismatch is large between the
186+paradigm that your program uses and the paradigm that you're mating it
187+with, consider building an explicit layer whose sole purpose is to
188+convert between the paradigms (see B5).
189+
190+### Correctness
191+
192+> A10: Correctness is more important than performance.
193+>
194+> A12: Correctness is more important than optimality.
195+
196+Sometimes you devise a solution which is fast but slightly incorrect.
197+This is rarely a good idea. Especially at lower layers of the system,
198+incorrectness expands as it bubbles up.
199+
200+Other times, you devise a solution which is correct, but you could
201+probably make it cheaper without sacrificing correctness. Sometimes
202+that's worth doing, other times it's not.
203+
204+Finally, in some cases you find a solution that's "optimal"
205+performance-wise or simplicity-wise, but it doesn't quite handle every
206+situation correctly. Maybe in the real world there are genuine
207+exceptions, and the code is much faster or simpler if you don't handle
208+those exceptions. In these cases, it's more important to handle every
209+case correctly than to "snap" to the nearest elegant formulation.
210+
211+> A11: Be simple and uncompromising in defining what's correct; go crazy
212+> with optimizations.
213+
214+Nock is a great example of this. It contains the character of the
215+virtual machine, but its asymptotics are bad. Add jets to fix the
216+asymptotics.
217+
218+Another example is the ACID nature of Arvo. Arvo is a pure
219+function f(logs) of its event log, so formally Arvo is just a
220+function run against an event log. A naive implementation has
221+very bad asymptotics; processing each new event is O(n) in the
222+number of historical events. Choose the function g(state,log)
223+such that f(logs ++ log) = g(f(logs),log). Then, as long as you
224+keep the state in memory, processing each new event is constant in
225+the number of previous events. This still requires O(n) restart
226+from disk, but you can also periodically (and non-blockingly)
227+write a checkpoint of the state to disk, so that restart from disk
228+is only linear in the number of events since the last checkpoint.
229+
230+This pretty much says it all. Define what's correct in as simple of
231+terms as possible — this will make it easier to implement and reason
232+about. Then don't compromise on it.
233+
234+> A13: If you don't completely understand your code and the semantics of
235+> all the code it depends on, your code is wrong.
236+
237+It's impossible to build correct code on a foundation that you're unsure
238+of. This is different than the problem of building something with
239+strong guarantees on top of something with weak guarantees — for
240+example, delivery guarantees on top of an unreliable transport protocol.
241+In that case, you are sure of the underlying system, it's just that what
242+you're sure of is that you can't rely on it delivering packets in order
243+or at all. So, you formalize what you *are* sure of, which is that it
244+will eventually get your packets through if you keep sending them
245+forever. And that's something you can build on.
246+
247+This is another reason it's important to have simple and accurate
248+correctness claims. When somebody else relies on your code, they
249+will need to know what exactly you claim to provide. If you're
250+accurate, then they don't have to understand your code, only your
251+guarantees.
252+
253+> A14: Deterministic beats heuristic.
254+
255+Heuristics make it hard to give precise safety guarantees, so you should
256+only use them when you don't guarantee much.
257+
258+> A17: Referential transparency is honesty and stability.
259+
260+A claim of referential transparency is a very strong guarantee, so it's
261+very useful for any code built on top of it. That code doesn't need to
262+know anything about how you produce the value because it can't
263+negatively affect the rest of the system, and it's free to cache
264+indefinitely.
265+
266+> A18: Responsibilities should be clearly separated.
267+
268+A program should be responsible for its own guarantees, though it must
269+rely on other programs to maintain their guarantees. You should avoid
270+guarantees that unduly couple separate programs. Any guarantee that
271+references state in more than one program is suspect.
272+
273+### State management
274+
275+> A1: Data is better than code
276+>
277+> A15: Stateless is better than stateful.
278+>
279+> A16: Explicit state is better than implicit state.
280+
281+Data is better than code, but code is better than state. If you must have state, state that is data is better than state that is code.
282+
283+There are many reasons for this. The most basic one is that humans are better at dealing with nouns than verbs. This is true to such an extent that we subconsciously convert statements of the form "so-and-so does such-and-such" to "so-and-so is a such-and-such-er". It's more challenging to view someone as a composition of their internal motivations such that they'll act in a particular way. It's much easier to see them as simply "friend" or "enemy" or "socialist" or "evil capitalist".
284+
285+Socially, the verb -> noun simplification is often problematic because it doesn't communicate the whole picture as accurately. It's an approximation that fails to capture important nuances. And that's because any nontrivial verb can't be understood in terms of a simple noun.
286+
287+However, the practical implications of this insight are different in code. Socially, people are who they are, so the best we can do is learn to understand them better. In code, though, we have a
288+powerful tool: convert the verbs to actual nouns. We can take advantage of our innate ability to reason about nouns and use that to make code that can more easily be reasoned about.
289+
290+Another way of looking at this is that data is easy to reason about. Code is hard to reason about, because it's much larger. Function types are known as "exponential types" because the number of possible functions between sets of size `m` and `n` is `n^m`. If there's global state of size `s`, this is even worse: `n^(m*s)`. The halting problem says that it's impossible in general to even determine if a piece of code will finish without running it.
291+
292+A final way of seeing this is that it's easier to reason about things that don't change. Data doesn't change, so it's a stable foundation. Pure code changes based on its arguments. Impure code changes based on its arguments and state. Impure code that uses code stored in its state
293+nests this whole complexity within itself.
294+
295+You can't, in general, update code in any way other than replacing it wholesale. This is not true of data, where to upgrade you just need a function from the old data type to the new data type.
296+
297+Sending code over the wire is problematic, because it's either very large or depends directly on what the other person has on their local ship. If you depend on what's on their ship and you're wrong, you may get the wrong result. So you explicitly require certain dependencies, at certain versions, ... this way lies dependency hell. There are ways to tame this, but if you just used data in the first place, those problems wouldn't exist.
298+
299+Of course, we can't always use data, precisely because it's smaller than code. And there are occasionally times when we could use either, but the code is actually easier to reason about than the data. All else equal, data > code > state of data > state of code.
300+
301+A note on laziness: lazily defined data occupies a middle ground. It's harder to reason about than strict data, but you get a lot more guarantees with it. It's probably not worth using as your basic substrate, but it makes some things easy to reason about.
302+
303+### CQRS/pubsub
304+
305+> A2: Everything should be CQRS.
306+>
307+> A3: (Almost) Everything should be pubsub.
308+>
309+> A4: A subscriber shouldn't affect a publisher.
310+>
311+> A5: Communication between nodes should be communication between
312+> independent actors.
313+
314+Fred Brooks pointed out that when you add people to an organization with `n` people, the number of interpersonal connections goes up with `n^2`. This is true of binary interpersonal connections, but if you allow groups of any subset of the people, then the number of total groups goes up with `2^n`.
315+
316+The same is true of entities in a program. A program must speak to many other programs about many things. Occasionally it can treat all others the same, so that the number of things it needs to say is constant in `n`. Sometimes it needs to say something different to each person, making it linear in `n`. Other times, it has a set of things it can speak about, say `m`. Pubsub lets the complexity grow with `m` instead of `n`. This lets the total communications grow with `m * n` instead of `n^2`.
317+
318+It's generally good to have more structure in how you communicate with other entities. If all you have is `send-message`, then you force each entity to define their norms around when messages are to be sent, and how to associate one message with another (eg a request to a response). This also gives the underlying system no visibility into the conversations.
319+
320+In CQRS+pubsub, we get a number of useful guarantees to help us structure our conversations. We know that a command will have no response other than exactly one positive or negative acknowledgment. We know that to request any data, we must have an active subscription, and
321+we know that a subscription may be canceled at any time. We know that a subscriber's failure to process a subscription update can't break the publisher. We know that after the initial subscription update, any subscriber to a path will get the same updates as anyone else on that
322+path.
323+
324+The underlying system can keep track of subscriptions, and can even cancel them automatically in certain circumstances (eg if the subscriber is on another ship and has stopped responding). This is like the nouns and verbs discussion above. Subscriptions are nouns, so we can reason about them better, and so can the underlying system. "Send a message" is a verb, so we have few guarantees about it.
325+
326+From Dijkstra's "Go To Statement Considered Harmful", which may as well have been written about unstructured event passing:
327+
328+> My second remark is that our intellectual powers are rather geared to
329+> master static relations and that our powers to visualize processes
330+> evolving in time are relatively poorly developed. For that reason we
331+> should do (as wise programmers aware of our limitations) our utmost to
332+> shorten the conceptual gap between the static program and the dynamic
333+> process, to make the correspondence between the program (spread out in
334+> text space) and the process (spread out in time) as trivial as
335+> possible.
336+
337+In our case, we make the programs of both the publisher and subscriber simpler by writing in terms of well-known constructs like "subscribe" and "push subscription update". You need to know much less about your counterparty.
338+
339+> A7: A client's representation of data should be as close as possible
340+> to that of the server.
341+
342+This is a natural architecture given pubsub, but it's also worth pursuing in its own right. This blurs the distinction between client and server, which makes the client more full-featured.
343+
344+It reduces communication to syncing, which means offline-mode is just a special case of sync latency, and all the local features are still usable.
345+
346+It also tends to reduce centralization, since you're already used to operating on your own, and you have all the data required to do so. The "server" becomes a commodity, easily moved when desired. Git is a good example of this — central git servers are common, but they're also a commodity, so you're never locked into a particular hosting provider. This is possible because the data structures are exactly the same on the client as on the server.
347+
348+> A23: Some cliches are repeated because they are true; others must be
349+> repeated because they are not.
350+
351+Computer security is an industry built on cliches. An example of the first is "your security is only as strong as your weakest link."
352+
353+An example of the second is "security through obscurity is ineffective". Security through obscurity is in fact the most effective form of security — if nobody cares about you, you will never be hacked. The problem is that you must remain obscure for it to work, and that's hard to explain to people in a precise way. It's effective at protecting precisely when there is nothing worth protecting. So, it's better (for them, their companies, and their users) to tell them a lie.
354+
355+However, it's important for whoever's coming up with the cliches to understand the specifics of how they're untruthful. Some of these very precepts may fall under the category of "literally untrue but more useful than the truth".
356+
357+<br>
358+
359+<img class="ba" src="https://media.urbit.org/site/posts/essays/discuss-03.jpg">
360+
361+## B: Specific Design
362+
363+There are some principles that aren't obviously better than the alternatives, but if you use them consistently you avoid a lot of issues. These are all examples of this.
364+
365+> B1: Always ack a dupe; never ack an ack.
366+>
367+> It's okay to ack a nack as long as you never nack a nack.
368+
369+This is a simple rule, and if you follow it you get various guarantees for free. For example, sending a message will always cause up to a constant number of additional messages to be sent by direct or indirect causality (other than application-level code), so you never have to worry about accidentally causing a loop.
370+
371+Additionally, acking an ack can never take you from imperfect to perfect reliability. Urbit isn't big on heuristics for stuff that's visible to userspace (A14), so don't even go down that road.
372+
373+Following this rule greatly reduces the architecture space for networks. This is very helpful in finding a good architecture.
374+
375+> B2: Never construct or deconstruct a duct.
376+
377+A duct is akin to a first-class call stack. Don't deconstruct that for the same reasons you shouldn't read your own call stack. If you read your own call stack, and do different things based on that, it breaks a lot of assumptions we have about messages. For example, we assume that a vane will handle a task the same way regardless if the initial IO event was a keystroke or a timer. Don't break that.
378+
379+Similarly, don't construct these by hand. This would be like inserting other functions into your own call stack and then returning to them. Powerful, yes, but pretty much always a bad idea because it breaks our assumptions.
380+
381+> B3: Route on wire before sign, never sign before wire.
382+
383+When we send a message to another vane or app, we send it on a wire. When we get a response to that message, we should care first about the wire it was sent on.
384+
385+It's tempting to shortcut that and route based on the type of response. Maybe you only call to `%iris` once in your app, so you feel like you can just route directly on that. But it doesn't scale, because that dimension is orthogonal to the true dimension you care about — which request this response corresponds to. This is essentially a violation of A6.
386+
387+> B4: Only go from statically typed to dynamically typed if you must.
388+
389+Consider the set `U` of all possible programs. Then consider "the program you want to write" to be a set `S` of programs that differ only in aspects you don't care about. For example, maybe one takes a little more time and one takes a little more memory, and maybe you don't care about that. This set has a generating "specification" — any program that meets that specification is in the set.
390+
391+A type system or testing suite can guarantee that a program is in another set `T`. Obviously, both `S` and `T` are in `U`. Hopefully the intersection of `S` and `T` is non-empty — that is the set of programs which typecheck and meet your spec.
392+
393+A perfect static type system can guarantee `T` is a subset of `S` — if it typechecks, then it works. Obviously, if you let `T := {}` (ie no program typechecks), then this is vacuously true. So you want `T` to be as large as possible while still being a subset of `S` — as many programs as possible typecheck without them being incorrect. But it can't make `T == S` — there will always be some programs that do the correct thing in practice, but the type checker can't prove that.
394+
395+Dually, a perfect testing suite can guarantee that `S` is a subset of `T` — no correct program fails the tests. This is vacuously true if you have no tests, for then `T = U`. So you want `T` to be as small as possible while still being a superset of `S` — you don't want to reject valid programs if you can help it. But you can't make `T == S` — there will always be some programs that are invalid but pass your typechecks (at least, if your program requires a Turing machine).
396+
397+(It is possible to create a static type system that has `S` subset `T` property described above for a testing suite — see Erlang's Dialyzerand [related work](http://user.it.uu.se/~tobiasl/publications/contracts.pdf).)
398+
399+A dynamic type system tells you neither of these ahead of time. Instead, you end up with type errors at runtime. Errors at runtime must be handled at runtime, when the programmer is not present. Errors at compile time are handled at compile time, when the programmer is present.
400+
401+There's a hybrid, which is "static type checks at run time". In other words, you load the code and run the type checks at run time. This is better than pure dynamic checking because as long as the code compiles, you get the guarantees of a static type system. But the later in the process that the code is compiled, or the more it's changed before compiling, the less guarantee you have that the type checker will pass. If a static type checker gives an error at a time when the programmer is not present (because it's run at runtime), that's worse than a dynamic type system — at least that would give it a chance of executing correctly!
402+
403+> B5: Anything with business logic speaks one paradigm; anything that
404+> translates paradigms has no business logic.
405+
406+Translating between paradigms with significant impedance mismatch is usually convoluted code. The state machines are often hard to see, and it tends to be quite cluttered.
407+
408+You want your business logic to be as clean and short as possible. This way the interesting algorithms are laid bare.
409+
410+> B6: Functionally enforced semantic rules are better security primitives
411+> than memory access restrictions.
412+
413+Memory access restrictions are blunt tools. Blunt tools are nice in simple systems, and if all you have is nails, then a hammer is perfect. But in practice you punch all sorts of holes in these restrictions, because you need more granularity and flexibility.
414+
415+Better to define rules in a more powerful language. This allows you to follow A6 and A8. It also lets you use all the correctness tools, like type systems, that you've developed for the rest of your code.
416+
417+<br>
418+
419+<img class="ba" src="https://media.urbit.org/site/posts/essays/discuss-04.jpg">
420+
421+### C: Attitude
422+
423+Good code is the result of people approaching the act of engineering with the right attitude.
424+
425+> C1: Code courageously.
426+
427+ If you avoid changing a section of code for fear of awakening the
428+ demons therein, you are living in fear. If you stay in the
429+ comfortable confines of the small section of the code you wrote or
430+ know well, you will never write legendary code. All code was
431+ written by humans and can be mastered by humans.
432+
433+ It's natural to feel fear of code; however, you must act as though
434+ you are able to master and change any part of it. To code
435+ courageously is to walk into any abyss, bring light, and make it
436+ right.
437+
438+The unix/internet stack is a giant ball of mud. It's so big that when you're standing on it, it looks like a bog, and it's not clear that there is a bottom to it. You know there must be, but it doesn't matter because you learned long ago that the best solution is to not dig too deep. Build a strong structure by spreading out your weight and using strong construction materials. If there's something useful deep in the mud, it's probably not worth diving in to pull it out. That's dangerous and prone to failure, and you know many people who have gotten stuck down there.
439+
440+This is an appropriate reaction to the unix/internet stack. It's also self-perpetuating. The bog is filled — even *composed* of — countless predecessors who did that same thing. If you ever find yourself on solid ground, protect that with your life. Learn how it works and how to use it well. Then build a strong structure on top of that. Don't let it decompose into a layer of mud.
441+
442+Urbit is small enough that, while there's definitely some construction-related dirt and muck covering it, the solid metallic core is not very deep — not more than waist deep in most places. The feeling of always being in contact with the bottom is very different than flailing about in a bog.
443+
444+This property is worth fighting for. It's the whole reason Urbit was written. New Urbit programmers are instinctively distrustful of anything below them and code defensively and fearfully. They must learn that it's all drastically simpler and more legible than they're used to. It's still hard, but you can actually make progress. To do so, you have to stand up straight, so you can get a firm footing on the ground. Keep your chin up and your shoulders back, and adopt the posture of a conqueror. When something doesn't work right, don't retreat into your shell of safety and control — fix it. The forces of chaos are always lurking, but their victory isn't inevitable. It's all on the line, so code with abandon.
445+
446+> C2: No time for lazy people.
447+
448+If there's clearly a right way to do something and a wrong way, do
449+it the right way. Coding requires incredible discipline. Always
450+follow conventions, and fire anyone who won't. Anything that can
451+be solved by discipline is not a real problem.
452+
453+> "To him who knows to do good and does not do it, to him it is
454+sin."
455+
456+Preserving the property of solid ground requires perpetual discipline. Once lost, it's often impossible to reacquire. Don't compromise your standards.
457+
458+Call people out when they're being lazy. And when someone calls you out, recognize it and fix it. Sometimes it's just a question on a code review — "why did you do it this way?" Upon reflection, you determine that you did it that way because you couldn't be bothered to do it right. Maybe that was a reasonable choice at the time you were coding so you wouldn't be distracted, but if it's been called out in a code review, now's the time to fix it, not make excuses.
459+
460+> C3: When a smart person makes an obviously stupid suggestion, before
461+> responding take a full 60 seconds to envision how you would implement
462+> it and what the effects would be.
463+
464+Once you've determined that someone understands a situation well, if they earnestly make a suggestion that you haven't thought of, or that you immediately dismissed as impractical, stop and consciously consider it. This is one of the best ways of countering the natural echo chamber
465+of your own mind.
466+
467+This is also one of the best ways to build stuff correctly. Very often, you will be tempted to cut a corner, and someone will point out that it should be done correctly. You should consider why you immediately rejected it. Was it because you were afraid of the relevant piece of code? If so, you should learn more about that code to determine if it's actually a good idea. Did you reject it because you felt it would distract you from working on what you thought was more important?
468+Consider carefully whether this particular piece of technical debt is worth taking on. It's worth 60 seconds of thinking about how you could solve it correctly right now — often it would be quite easy to do correctly and you'd be paying interest on the incorrectness for a long time.
469+
470+<br>
471+
472+<img class="ba" src="https://media.urbit.org/site/posts/essays/discuss-05.jpg">
473+
474+### D: Theory
475+
476+The eternal tension between theory and practice must not simply be acknowledged, but dealt with.
477+
478+> D1: Academia is a succubus.
479+
480+The results from academia are useful to take advantage of, but the process of academia is a deadly sin for a project as ambitious as Urbit.
481+
482+Academia usually gets the right answer, but it's slow, and it often cycles through a large number of wrong answers before it gets to the right one. It's also unconcerned with many things that a real project must consider. For example, it's generally more concerned with mathematical simplicity than mechanical simplicity, contradicting A21.
483+
484+> D3: Not being qualified to solve a problem is no reason not to solve it.
485+>
486+> D4: The best way to get the right answer is to try it the wrong way.
487+>
488+> D6: Everyone must regularly alternate between theory and practice.
489+
490+One common failure mode for academia is to get bogged down in optimally solving a particular part of a problem such that it fails to solve the whole problem.
491+
492+There's a sense of "if I don't know how to do it, I must discover the correct answer before I can do it". This will get you the right answer if it terminates, which is the sort of algorithm mathematicians like. Engineers like algorithms that do in fact terminate.
493+
494+The fastest way to build a good system is to build it as well as you know how, then iterate on it. You have to be disciplined about actually iterating over time as you learn about the problem, but often the way to learn more about the problem is to move beyond it and work on adjacent
495+problems. Hindsight is 20/20, so get the problem in your rearview mirror as fast as possible. Then while you're driving somewhere else, you'll see what you should have done. Then turn around and go do it. This only works if you or someone else is willing to go back and fix it
496+(C2).
497+
498+> D2: Never fear math.
499+
500+You can spend years working on a problem that you're able to solve in a few days with the right theoretical grounding. There's no excuse for being ignorant of theory; or rather, being ignorant of theory is an excuse to learn it.
501+
502+Many engineers fear theory the same way they fear a complex piece of code deep in the stack (C1). But they shouldn't, because theory is rarely muddy. The same characteristics that make theory impractical also make it clean and learnable. It's also pretty permanent, so a one-time investment will pay dividends for a long time.
503+
504+Of course, if you look deep down, you may find laziness is what's keeping you from learning theory. If that's the case, you need to decide how much you want to design good software. Because there's no room for laziness (C2).
505+
506+> D5: Practice tells you that things are good or bad; theory tells you why.
507+
508+You can never tell whether a system is good or bad without using it (see discussion on A21). Theory has great explanatory power, but only limited exploratory power. The best it can do is point out areas of the idea maze you haven't explored and suggest correlations between
509+objective properties and your subjective judgment of the quality of the system.
510+
511+However, that explanatory power is indeed powerful, and the exploratory suggestions are often able to break you out of a rut (attractor basin). Respect the tension.
512+
513+<img class="ba" src="https://media.urbit.org/site/posts/essays/discuss-06.jpg">
514+
515+<br>
516+
517+### E: Text Style
518+
519+Code form matters. Code that is hard to read is hard to maintain. Code that is inconsistently formatted is hard to read, but consistency isn't the end of the story. Some formats are simply hard to read.
520+
521+Formatting also isn't the end of the story. Naming and commenting conventions are even more important to clarity. The human brain is quite good at taking stuff that's in an unexpected form and interpreting it.
522+
523+This is why the diversity of accents and handwriting rarely causes issues, while the diversity of languages requires specialized translators. For someone used to typing on a QWERTY keyboard, it takes some time to get used to typing on a Dvorak keyboard because you have to rewrite your muscle memory. But it's nothing like how hard it is to learn another language. Russian script is roughly as different from English script as Russian grammar is from English's, but it's drastically easier to learn to read, handwrite, and type Cyrillic than it is to learn Russian grammar.
524+
525+So, uniformity of style is good, but it's not sufficient. The style must be readily readable and writable.
526+
527+### Formatting
528+
529+> E1: No code should extend beyond 80 characters, most within 55.
530+
531+Very wide code is unreadable. Even before you get to the readability threshold, it's useful to keep your code relatively narrow. Too narrow of code, on the other hand, results in too tall of code. What these two have in common is that they make it hard to navigate the code.
532+
533+Code navigability is the ability to find the part of the code you're looking for. This has several inputs:
534+
535+- how far away is what you're looking for?
536+- how many distinct places in the code can you have on screen?
537+- how much code can you have on screen?
538+- how fast can you recognize that you're in the correct place?
539+
540+Some of these are strongly affected by workflows. We can't force a developer to have an effective workflow, but we can support those who do. If your workflow is deficient in one of these areas, consider improving it.
541+
542+One of the primary inputs to code navigability is how much of it you can have on your screen. Code that is too wide limits the number of columns of code. Some people keep only one column on their screen, so they don't see a problem with long lines of code. The most efficient navigation is to already be there (i.e. to only have to move your eyes). If you only have one column of code open, you can only be in one place, which eliminates the best form of navigation.
543+
544+Dually, code that is too narrow limits the number of lines you can have on a screen (this isn't a separate precept simply because we've never had to tell someone to write *wider* code). This suggests there is some happy medium. This is dependent on the language, but in Hoon we've
545+found that up to 55 columns is a pretty good number for most code. However, there are plenty of legitimate reasons to go a bit longer than that. 70 columns is rare, but not surprising. There is essentially never a reason to extend beyond 80 columns.
546+
547+> E2: Tabs aren't real.
548+
549+Code is a text file, and text files are WYSIWYG. The reader should view the file exactly the same as the author wrote it. This is a low-overhead way of avoiding editor-dependence in code, which is as bad as browser-dependence in javascript. Sure, tabs aren't as big a deal as the hell that front-end devs have to deal with, but there's no reason to give an inch to the forces of platform-dependence.
550+
551+Some argue in favor of "customization". Customization is inconsistency.
552+There can be good reason for inconsistency in some areas, but not in
553+code formatting, which is such an intensely communicative action.
554+
555+> E3: A text file is a series of lines, each ending with a newline
556+ character.
557+
558+There are several competing definitions of text files, but most commonly-used software uses this one. It's simple and consistent.
559+
560+Its disadvantage relative to "a text files is a series of characters, possibly including newlines" is that there are some arrangements of characters that are not valid text files (ie non-empty and not ending in a newline). However, some series of characters were already not valid
561+in a text file — eg those including control characters or other nonrepresentable characters.
562+
563+In return, we get the advantage that we can treat a text file as having a more complex and useful structure — a list of lists of characters, rather than simply a list of characters.
564+
565+These are theoretical concerns — the real answer is that it's the way it's always been done, and deviating from that without a good reason is asking for trouble.
566+
567+### Names and comments
568+
569+> E4: One block comment is better than interleaved comments on every line.
570+
571+Interleaved comments are easy to write because you can just paraphrase the code. This is also why they're generally useless. In the micro, code should always be immediately understandable. In the macro, it's often helpful to give context as to the purpose or constraints of the function. Sometimes it's good to even give the algorithm line-by-line in pseudocode, but mixing the pseudocode with the real code obfuscates both.
572+
573+> E5: Don't name anything you don't have to.
574+
575+> E6: If it's the same thing, give it the same name.
576+
577+It is often said that there are two hard things in computer science: cache invalidation and naming things. This is a good aphorism. As often, someone will respond with "There are two hard things in CS: cache invalidation, naming things, and off-by-one errors". This is a weak
578+joke because off-by-one errors are not hard at all. They're mostly a matter of discipline, and there's a couple of conventions that help. If you're looping on a zero-indexed variable, use `i < num_loops`. If you're looping on a one-indexed variable, use `i <= num_loops`.
579+
580+However, cache invalidation and naming things are genuinely hard because they must be solved ad hoc. There is no one-size-fits-all cache invalidation strategy, and possibly there never will be. Similar for naming. So you must actually comprehend and work within each individual
581+context.
582+
583+You shouldn't solve hard problems if you don't need to, so don't name anything you don't have to. Giving unique names to things is tiring, and it reduces readability. A consistent pattern for naming things makes it easy to keep track of what is what and reduces the number of
584+decisions you must make.
585+
586+Examples:
587+
588+- If the only difference between three things is that they're not the
589+ same, consider naming them `thing-1`, `thing-2`, and `thing-3`.
590+
591+- Use agglutinative morphology. If `a` is to `b` as `c` is to `d`, then
592+ find an affix which describes this distinction (say `-suf`) and rename
593+ them to `a`, `a-suf`, `c`, and `c-suf`.
594+
595+- A corollary of the above is that if one variable represents the "same"
596+ thing with a different type, that type should be the morpheme added.
597+ For example, if `a-set` is a set, then `~(tap in a)` should be called
598+ `a-list`.
599+
600+- Don't abbreviate (E8) — everyone abbreviates differently, and bits are
601+ cheap. If it takes you a long time to type the name, consider (1)
602+ finding a more succinct name (good any time you can do it), (2)
603+ becoming a faster typer, or (3) learning autocomplete tools, such as
604+ snippets.
605+
606+- Especially don't abbreviate or otherwise change the word when adding
607+ affixes. Inflectional morphology is bad in such an ad hoc context as
608+ code.
609+
610+> E7: Humans are good at memorizing.
611+
612+We're really good at memorizing sets of things, like runes. We're also good at inferring structure from patterns. We're bad at memorizing structure in apparently unrelated names, though, and once we see a pattern, we assume it's densely populated.
613+
614+So don't be afraid to use new names for new concepts. If concepts are siblings, they needn't necessarily have a direct connection in their name, but if they're hierarchical, then something should suggest that. This can be syntactic or semantic.
615+
616+<br>
617+
618+<img class="ba" src="https://media.urbit.org/site/posts/essays/discuss-07.jpg">
619+
620+### F: Real Software
621+
622+Not all software matters. Or at least, not all software comes within
623+the scope of "Urbit". Urbit cares about "Martian software".
624+
625+> F9: Timeless software is good software.
626+
627+There's different sorts of software. A lot of software is inherently ephemeral, and can really only be run in one place. A SAAS company runs bespoke software on a particular set of servers, and that software has no future. It will never be run on anyone else's servers, and it will eventually stop being run even there. It won't even have any direct descendents. It's a genetic dead end.
628+
629+However, not all software is this way. Urbit is interested in software that can live forever. This is what we call "real" software.
630+
631+This is the most important passage in all that has ever been written
632+about Urbit:
633+
634+> What is Martian code actually like? There are two possibilities.
635+>
636+> One: since Earth code is fifty years old, and Martian code is fifty
637+> million years old, Martian code has been evolving into a big ball of mud
638+> for a million times longer than Earth software. (And two million times
639+> longer than Windows.)
640+>
641+> This hypothesis strikes me as possible, but implausible. Since the *big
642+> ball of mud* expands indefinitely, Martian code would therefore be so
643+> large and horrible that, despite its underground installed base, the
644+> server room bulged into space like a termite mound, intercepting
645+> low-flying asteroids and stinking up the solar system all the way to
646+> Pluto. Our latest space telescopes would surely have detected this
647+> abominable structure - if not, in fact, collided with it.
648+>
649+> Two: therefore, at some point in Martian history, some abject fsck of a
650+> Martian code-monkey must have said: *fsck* this entire fscking ball of
651+> mud. For *lo*, its defects cannot be summarized; for they exceed the
652+> global supply of bullet points; for numerous as the fishes in the sea,
653+> like the fishes in the sea they fsck, making more little fscking fishes.
654+> For lo, it is *fscked*, and a big ball of mud. And there is only one thing
655+> to do with it: *obliterate* the trunk, *fire* the developers, and hire a
656+> whole new fscking *army* of Martian code-monkeys to rewrite the *entire
657+> fscking thing*.
658+>
659+> This is such an obvious and essential response to the *big ball of mud*
660+> pattern that, despite the fact that we know nothing about Mars, we can
661+> deduce that it must have happened on Mars. Probably several times.
662+> Probably several hundred. For each of these attempts but the last, of
663+> course, the result was either (a) abject failure, (b) another *big ball
664+> of mud*, or (c) both.
665+>
666+> But the last, by definition, succeeded. This is the crucial inference we
667+> can draw about Mars: since the Martians had 50 million years to try, in
668+> the end they must have succeeded. The result: Martian code, as we know
669+> it today. Not enormous and horrible — *tiny and diamond-perfect*.
670+> Moreover, because it is tiny and diamond-perfect, it is perfectly stable
671+> and never changes or decays. It neither is a *big ball of mud*, nor tends
672+> to become one. It has achieved its final, permanent and excellent state.
673+
674+We don't know that Urbit will achieve this final form, but Urbit is an attempt to make progress in that direction. Any software that isn't a candidate for "tiny and diamond-perfect" is either a prototype or scaffolding.
675+
676+Here's some characteristics of real software:
677+
678+> F1: If it's not deterministic, it isn't real.
679+
680+If you do the same thing twice, your computer should react the same way. This is comforting. This is also what makes it easy to reason about and use effectively. If you're not sure what your computer will do, you'll be afraid of it and act defensively toward it. This inevitably leads to a big ball of mud.
681+
682+Diamonds are extremely hard, and they wear very slowly. A diamond surface will support you every time; a mud surface will shift out from under you exactly when you put weight on it.
683+
684+> F2: If it's centralized, it isn't real.
685+
686+Code that depends on a central authority or has a single point of failure is fundamentally brittle. No authority lasts forever, no company lasts forever, no server lasts forever. Under certain
687+circumstances, bones and the like can be preserved for a long time — but not alive. The remains of buildings sometimes last for thousands of years, but the cities are gone.
688+
689+The only things that last forever in their useful form are big hunks of rock (like the pyramids at Giza) and ideas, through writing and transcription. So, if you depend on the sun existing, this is
690+acceptable. If you depend on a piece of source code to be kept forever, copied and re-copied, you're fine. If you depend on a 20-year-old company existing and being easily accessible, this is brittle.
691+
692+Another way to look at this is to say that anything that wouldn't work on a spaceship is architecturally flawed. Maybe it requires many sequential round-trips to a central server because it doesn't have all the relevant information. See discussion of A7.
693+
694+> F3: If it's owned by someone else, it isn't yours.
695+>
696+> F4: If it's managed by someone else and you can't change who that is, it
697+> isn't yours.
698+>
699+> F5: If it's not yours, it isn't permanent.
700+>
701+> F6: If it's not permanent, it isn't real.
702+
703+Nobody is as aligned with your values as you are. If you don't control the software, then you can't guarantee you'll always have access to it. Whoever does control the software may destroy it, move away, or simply revoke your access to it.
704+
705+Control has some nuance. If it's physically controlled by a company and you can't get your data and the software that makes it useful, you definitely don't have control. If you have physical control of it, you do have control. But if you're hosting the data and software on a commodity cloud server, you still mostly have control of it. Your privacy has been reduced, sure. However, as long as you keep regular backups of the data and software, if the hosting provider disappears you just need to find another host, or host it yourself. Any particular host is likely to disappear, but the situation where *every* host disappears and you can't even host it yourself is much less likely. Brands are mortal, commodities are not.
706+
707+Some branded hosts allow you to download a zip file of your data. This gives you a little more control over your data, but it's much closer to "no control" than "total control". This is because your online world is data plus code, and without the code that makes it useful, data is only good for scrapbooking. The scrapbook will remind you of the good old days, but you won't be able to live them again.
708+
709+> F16: Sovereignty necessitates understanding.
710+
711+Not everyone cares to understand the software they're using. But if you want to compute sovereignly, you must understand what your computer is doing. If it regularly surprises you, you're not in control of it. You must tame it. The current paradigm is a wild monster which cannot be tamed by mere humans — only megacorporations even attempt to do so, and it's always temporary. So, your software needs to be simple enough that it can be understood.
712+
713+> F10: System modules should be designed to be frozen permanently;
714+> conversely, Urbit consists of that system software which admits of a
715+> Kelvin version.
716+
717+"Kelvin versioning" is a versioning scheme where your current version is a natural number, and new versions count down. Once you hit version 0, no more changes should be necessary.
718+
719+This is the opposite of the usual way of developing software, where there is no defined endpoint. This paradigm suggests that you're building something specific. Most current software builds higher and higher in a vain attempt to reach the heavens, until all available effort is expended just to keep this tower from falling over. Kelvin versioned software cuts away until you reach a strong bedrock. Not every piece of software should have a Kelvin version, but infrastructure should.
720+
721+> F11: The two procedures for achieving timelessness are distillation and
722+> generalization.
723+
724+When building a timeless system, you start by building whatever you need to make it work. Then as you continue on, you may find some of the features are no longer necessary. Often, they're only needed when you're using them for user-facing work, but you've already moved on to building user-facing stuff somewhere else. You don't need the niceties anymore, so you should remove them.
725+
726+Other times, you find that you want something similar to a feature you already have, but not exactly the same. When this happens often enough with the same feature, you may discover what is the essential nature of the feature and what are simply ornaments of the original use of the feature. Then, you can generalize the feature so that each of the desired use cases is well served.
727+
728+> F13: That which cannot be Kelvin-versioned should update fluidly and
729+> automatically.
730+
731+Not everything should be Kelvin versioned. Much user-facing code is in a continual process of discovery, and it must react to changing userbases and their needs. These should update without user interaction. You should be able to turn off your ship for years at a time, then turn it back on. After a few minutes or hours of catching up, you should be ready to go.
732+
733+This means you need upgrade paths to be permanent, and they must not lose information. Anything that stops being able to upgrade is not permanent, since it will succumb to bit rot.
734+
735+> F14: Humans are interactive and temporal; technology is permanent and
736+> exhaustive.
737+
738+This is why the software humans touch directly should not be Kelvin
739+versioned but the infrastructure that makes it work should be.
740+
741+> F7: The way it is isn't always the way it ought to be.
742+
743+You should presume that there's a good reason for why things are done a certain way because what works best tends to win in a market in the long term, but markets are rarely efficient. Markets become more efficient over time, if they become more liquid, and as they become larger. Software is young, the cost of switching technologies is often large, and the space of software paradigms yet to be explored dwarfs those we've exhausted. So don't be surprised if you find ways to improve the situation drastically.
744+
745+> F8: The way it ought to be isn't always the way it is.
746+
747+On the other hand, sometimes the elegant solution just isn't right. The ultimate test of the quality of software is whether it's useful to humans. Humans don't fit nice equations, so the timeless truths of mathematics are often mismatched with human convenience. Never sacrifice real utility for the sake of making the code more elegant.
748+
749+> F12: Standardization is better than perfection.
750+
751+Coordination problems are some of the most difficult. When given a choice between compatibility and improvement, carefully consider whether the problem solved by the improvement is weightier than the problem caused by the incompatibility.
752+
753+> F15: Communities are autonomous.
754+
755+This is both a positive statement and a normative one. Communities are in fact a thing separate from their platform, but sometimes changes in the platform can kill them. That's bad. It's slightly different from freedom of association, since that's a freedom that applies to individuals, not the communities themselves.
756+
757+Communities are the basic building blocks of society. We are each a member of some number of communities, and most power is held by these communities. Some communities coincide with family ties, some with common goals, beliefs, or interests. Some may be freely joined by just showing up — others are nearly impossible to join without having been born into them.
758+
759+Throughout civilization society has had many forms. Governments have ranged from police states to feudal societies to democracies to informal tribes of people. In each of these, the fundamental unit is the community. Humans don't live on their own, and they don't live in one
760+universal society. They are a part of some communities and not of others.
761+
762+Technology shouldn't force us into a single global community. Discoverability isn't an unmitigated good. Most communities should be closed off from each other — that's what makes them a community. This allows them to develop their own ideas and norms. These bleed into
763+other communities and may spread if they provide some benefit.
764+
765+Many technologies today combine us into a single community, or at least a single set of norms. If many communities are hosted by a single entity, there will be pressure from some of those communities toward the entity to pressure other communities to follow certain of their norms.
766+This crosstalk isn't all bad, but there must be an equilibrium. All too often the lines between the communities are so permeable as to be inconsequential. In this case, the communities will converge in a single large community, at the cost of the memetic diversity of the original communities.
767+
768+Technology should mirror human interaction, and humans interact in communities.
content/blog/precepts.mdnew file+355
@@ -0,0 +1,355 @@
1++++
2+title = "Precepts"
3+date = 2020-03-18
4+description = "Technical maxims that define Urbit's approach to engineering."
5+[extra]
6+author = "Philip Monk"
7+ship = "~wicdev-wisryt"
8+image ="https://media.urbit.org/site/posts/essays/pre-01.jpg"
9++++
10+
11+<br>
12+
13+<img class="ba" src="https://media.urbit.org/site/posts/essays/pre-01.jpg">
14+
15+Urbit is a principled approach to system design and programming, but it's often not obvious what those principles are. We have many specific terms for the different parts of the project: Arvo is the OS, Hoon is the language, Tlon is the company, Azimuth is the identity system, Ames is the network. But the word most associated with the project is "Urbit", and it's not clear what technically it refers to. It's only a small stretch to say that "Urbit" *is* this set of principles, and that if anybody follows these principles strictly they will create a system that is isomorphic to the Urbit.
16+
17+Some of these are commonly held among many software projects, and some are not. Some are only debatably better than the alternatives, but Urbit exclusively chooses them.
18+
19+We’ll start with a brief description of many principles, then we’ll go into a long-form justification.
20+
21+<br>
22+
23+<img class="ba" src="https://media.urbit.org/site/posts/essays/pre-02.jpg">
24+
25+
26+### A: General Design
27+
28+1) Data is better than code.
29+
30+ Store data in your state, send data over the wire, dispatch based
31+ on data.
32+
33+2) Everything should be CQRS.
34+
35+3) (Almost) Everything should be pubsub.
36+
37+4) A subscriber shouldn't affect a publisher.
38+
39+5) Communication between nodes should be communication between
40+ independent actors.
41+
42+ Each message should do one complete thing, and there shouldn't
43+ need to be a sequence of coupled messages.
44+
45+6) Represent your data as closely as possible to the essential structure
46+ of the problem.
47+
48+7) A client's representation of data should be as close as possible to
49+ that of the server.
50+
51+ This blurs the distinction between client and server. It allows
52+ offline-mode, reduces communication to syncing, and decentralizes.
53+
54+8) When mating different paradigms, build one cleanly on top of the
55+ other.
56+
57+ Never try to make them work on some of the same primitives. Never
58+ abuse one to make the other work. For example, ducts in
59+ themselves are very general - if you want to do pubsub, that can
60+ easily be built on top of ducts, but don't pretend that pubsub is
61+ a *part* of the duct system.
62+
63+9) Never misuse an abstraction.
64+
65+ An abstraction provides a certain set of tools; use them and only
66+ them.
67+
68+10) Correctness is more important than performance.
69+
70+11) Be simple and uncompromising in defining what's correct; go crazy
71+ with optimizations.
72+
73+ Nock is a great example of this. It contains the character of the
74+ virtual machine, but its asymptotics are bad. Add jets to fix the
75+ asymptotics.
76+
77+ Another example is the ACID nature of Arvo. Arvo is a pure
78+ function f(logs) of its event log, so formally Arvo is just a
79+ function run against an event log. A naive implementation has
80+ very bad asymptotics; processing each new event is O(n) in the
81+ number of historical events. Choose the function g(state,log)
82+ such that f(logs ++ log) = g(f(logs),log). Then, as long as you
83+ keep the state in memory, processing each new event is constant in
84+ the number of previous events. This still requires O(n) restart
85+ from disk, but you can also periodically (and non-blockingly)
86+ write a checkpoint of the state to disk, so that restart from disk
87+ is only linear in the number of events since the last checkpoint.
88+
89+12) Correctness is more important than optimality.
90+
91+13) If you don't completely understand your code and the semantics of
92+ all the code it depends on, your code is wrong.
93+
94+14) Deterministic beats heuristic.
95+
96+ Heuristics are evil and should only be used where determinism is
97+ infeasible, such as in cache reclamation.
98+
99+15) Stateless is better than stateful.
100+
101+16) Explicit state is better than implicit state.
102+
103+17) Referential transparency is honesty and stability.
104+
105+ Lack of referential transparency and other forms of
106+ disingenuousness are some of the world's big problems. Only
107+ deviate from referential transparency if absolutely necessary.
108+
109+18) Responsibilities should be clearly separated.
110+
111+ This applies from kernel modules through network citizens.
112+
113+19) Dualities must be faced head-on and analyzed differently at
114+ different layers.
115+
116+ Statically typed vs. dynamically typed, imperative vs. functional,
117+ code vs. data, and effectful vs. pure can all be a matter of
118+ perspective, and all relevant perspectives must have coherent
119+ answers.
120+
121+20) One hundred lines of simplicity is better than twenty lines of
122+ complexity.
123+
124+ It's not enough for an abstraction to reduce code duplication; it
125+ must actually make the code simpler.
126+
127+21) Prefer mechanical simplicity to mathematical simplicity.
128+
129+ Often mechanical simplicity and mathematical simplicity go
130+ together.
131+
132+22) The Law of Leaky Abstractions is a lie; abstract airtightly.
133+
134+ If your abstractions are leaking, it's not due to some law of the
135+ universe; you just suck at abstracting. Usually, you didn't
136+ specify the abstraction narrowly enough.
137+
138+23) Some cliches are repeated because they are true; others must be
139+ repeated because they are not.
140+
141+<br>
142+
143+<img class="ba" src="https://media.urbit.org/site/posts/essays/pre-03.jpg">
144+
145+### B: Specific Design
146+
147+1) Always ack a dupe; never ack an ack.
148+
149+ It's okay to ack a nack as long as you never nack a nack.
150+
151+2) Never construct or deconstruct a duct.
152+
153+3) Route on wire before sign, never sign before wire.
154+
155+4) Only go from statically typed to dynamically typed if you must.
156+
157+ Once you go into a dynamically typed world, it's hard to go back.
158+ Statically typed is better than dynamically typed, so if something
159+ can be made static, it should be.
160+
161+ Each timeless data structure is a brick in the foundation of
162+ digital civilization.
163+
164+5) Anything with business logic speaks one paradigm; anything that
165+ translates paradigms has no business logic.
166+
167+6) Functionally enforced semantic rules are better security primitives
168+ than memory access restrictions.
169+
170+ A compiler can use type safety as an effective tool to enforce
171+ some classes of security guarantees.
172+
173+<br>
174+
175+<img class="ba" src="https://media.urbit.org/site/posts/essays/pre-04.jpg">
176+
177+### C: Attitude
178+
179+1) Code courageously.
180+
181+ If you avoid changing a section of code for fear of awakening the
182+ demons therein, you are living in fear. If you stay in the
183+ comfortable confines of the small section of the code you wrote or
184+ know well, you will never write legendary code. All code was
185+ written by humans and can be mastered by humans.
186+
187+ It's natural to feel fear of code; however, you must act as though
188+ you are able to master and change any part of it. To code
189+ courageously is to walk into any abyss, bring light, and make it
190+ right.
191+
192+2) No time for lazy people.
193+
194+ If there's clearly a right way to do something and a wrong way, do
195+ it the right way. Coding requires incredible discipline. Always
196+ follow conventions, and fire anyone who won't. Anything that can
197+ be solved by discipline is not a real problem.
198+
199+ > "To him who knows to do good and does not do it, to him it is
200+ sin."
201+
202+3) When a smart person makes an obviously stupid suggestion, before
203+ responding take a full 60 seconds to envision how you would implement
204+ it and what the effects would be.
205+
206+<br>
207+
208+<img class="ba" src="https://media.urbit.org/site/posts/essays/pre-05.jpg">
209+
210+### D: Theory
211+
212+1) Academia is a succubus.
213+
214+ Academia has a really high ratio of smart people to useful
215+ products. Academia has many genuinely smart and interesting
216+ ideas, but always remember that pursuing them whole-heartedly will
217+ never result in a useful product.
218+
219+2) Never fear math.
220+
221+ Academia is inefficient, but it's also correct. Those people
222+ wasted a lot of time finding the right answer, but now that
223+ they've done it, you must exploit it. If you don't know the
224+ theory, learn it. No excuse for being "bad at math". Most who
225+ are "bad at math" are simply lazy or fearful. Be strong and of
226+ good courage. If you're truly so bad at math that you cannot
227+ learn it, you should not design systems.
228+
229+3) Not being qualified to solve a problem is no reason not to solve it.
230+
231+ If you don't know how to do it, do it anyway. "We are too young
232+ to realize that certain things are impossible. So, we will do
233+ them anyway."
234+
235+4) The best way to get the right answer is to try it the wrong way.
236+
237+ You cannot design a good system without spending most of your time
238+ in contact with the problem. The bad parts about systems are
239+ rarely obvious in theory, but often in practice.
240+
241+5) Practice tells you that things are good or bad; theory tells you why.
242+
243+ Never use theory to design a good system from scratch; only
244+ practice can tell whether the system is good.
245+
246+6) Everyone must regularly alternate between theory and practice.
247+
248+ There is an eternal wheel of system design. Given a system, use
249+ practice to discover what is bad, missing, or unnecessary. Then,
250+ use theory to fix the bad, add the missing, and remove the
251+ unnecessary. Repeat.
252+
253+<br>
254+
255+<img class="ba" src="https://media.urbit.org/site/posts/essays/pre-06.jpg">
256+
257+### E: Text Style
258+
259+1) No code should extend beyond 80 characters, most within 55.
260+
261+2) Tabs aren't real.
262+
263+3) A text file is a series of lines, each ending with a newline
264+ character.
265+
266+ Corollary: all non-empty text files end with a newline (often
267+ hidden by editors). An empty text file does not end with a
268+ newline.
269+
270+4) One block comment is better than interleaved comments on every line.
271+
272+5) Don't name anything you don't have to.
273+
274+ This includes conventional names for variables of particular
275+ types. For example, the conventional name for a variable of type
276+ `path` is `pax`. You should have a good reason for using any
277+ other name for a `path`.
278+
279+ A more recent convention that follows the same principle is to
280+ give the variable the same name as its type.
281+
282+6) If it's the same thing, give it the same name.
283+
284+7) Humans are good at memorizing.
285+
286+8) Abbreviations aren't worth it.
287+
288+<br>
289+
290+<img class="ba" src="https://media.urbit.org/site/posts/essays/pre-07.jpg">
291+
292+### F: Real Software
293+
294+1) If it's not deterministic, it isn't real.
295+
296+2) If it's centralized, it isn't real.
297+
298+3) If it's owned by someone else, it isn't yours.
299+
300+4) If it's managed by someone else and you can't change who that is, it
301+ isn't yours.
302+
303+5) If it's not yours, it isn't permanent.
304+
305+6) If it's not permanent, it isn't real.
306+
307+7) The way it is isn't always the way it ought to be.
308+
309+ If you can make it the way it ought to be, do so.
310+
311+8) The way it ought to be isn't always the way it is.
312+
313+ Some things can't be made more elegant.
314+
315+ For every ailment under the sun
316+ There is a remedy, or there is none;
317+ If there be one, try to find it;
318+ If there be none, never mind it.
319+
320+9) Timeless software is good software.
321+
322+10) System modules should be designed to be frozen permanently;
323+ conversely, Urbit consists of that system software which admits of a
324+ Kelvin version.
325+
326+11) The two procedures for achieving timelessness are distillation and
327+ generalization.
328+
329+ Every temporary or contingent feature in a system module should
330+ eventually either be removed (distillation) or relaxed into
331+ timelessness (generalization). For an example of the result of
332+ both procedures, consider the abstraction of the core in Nock and
333+ Hoon.
334+
335+12) Standardization is better than perfection.
336+
337+ Kelvin versioning stops when we run out of versions, not when
338+ every defect has been rectified.
339+
340+13) That which cannot be Kelvin-versioned should update fluidly and
341+ automatically.
342+
343+ All incompatible upgrades should provide permanent and automatic
344+ upgrade paths. This is principled permanent backward
345+ compatibility.
346+
347+14) Humans are interactive and temporal; technology is permanent and
348+ exhaustive.
349+
350+15) Communities are autonomous.
351+
352+16) Sovereignty necessitates understanding.
353+
354+ If you don't understand a system you're using, you don't control
355+ it. If nobody understands the system, the system is in control.
content/understanding-urbit/simple-durable-yours.md → content/blog/simple-durable-yours.mdrenamed+2−5
@@ -1,11 +1,8 @@
11+++
22title = "Simple, Durable, Yours"
3−description = "The core ideas that Urbit is built around"
4−weight = 1
3+date = 2019-10-17
4+description = "We built Urbit from scratch to be a system that’s simple, durable, and yours. Everything that computing today is not — but should be."
55[extra]
6−flatten_pagination = "true"
7−hide_next_title = "true"
8−hide_previous_title = "true"
96+++
107
118We live in a world dense with digital services. We see the world through them, we depend on them completely, and they’re not going away. They’re only becoming more ubiquitous.
content/blog/the-dao-as-a-lesson-in-decentralized-governance.md+1−1
@@ -2,7 +2,7 @@
22title = "The DAO as a Lesson in Decentralized Governance"
33date = 2016-06-24
44description = "What's the right lesson for the decentralization community to learn from the collapse of the DAO?"
5−aliases = ["/posts/essays/the-dao-as-a-lesson-in-decentralized-governance", "/posts/the-dao-as-a-lesson-in-decentralized-governance"]
5+aliases = ["/posts/essays/the-dao-as-a-lesson-in-decentralized-governance", "/posts/the-dao-as-a-lesson-in-decentralized-governance", "/blog/dao"]
66[extra]
77author = "Curtis Yarvin"
88ship = "~sorreg-namtyv"
content/blog/urbit-for-normies.mdnew file+177
@@ -0,0 +1,177 @@
1++++
2+title = "Urbit for Normies"
3+date = 2020-02-12
4+description = "A layperson’s guide to the coming new internet."
5+[extra]
6+author = "Erik Newton"
7+ship = "~patnes-rigtyn"
8+image ="https://media.urbit.org/site/posts/essays/normies-2.png"
9++++
10+
11+Urbit is a challenging project to fully describe because, rather than a single product, it’s an entire system. Often when I talk about one of the individual elements of the system, someone will tell me that another company is already building that — and they’re usually right. What sets Urbit apart is that we’re building all these elements at once to work together seamlessly.
12+
13+For that reason, this overview is long. I wanted to explain, at a very high level, as much of the system as possible, to share an image of the entire forest rather than spending too much time on any of the trees.
14+
15+My own path to Urbit was not predictable, so it turns out I’m a useful ambassador to describe what the heck we’re doing to my fellow normies.
16+
17+I refer to myself as a normie because I’m a lawyer by training, not the typical code-savvy early Urbit adopter. I ran a law firm and, after retiring, founded a podcast and magazine about relationship dynamics. During that time I came to believe that humanity was in desperate need of better ways to relate. I didn’t know how, but I knew that my podcast about romance wasn’t going to move the needle. I began to look for a bigger project. I wanted something I truly could invest myself in; something that could have a real impact on this problem.
18+
19+That’s when a friend introduced me to Urbit. Saying it was the most credible project he’d seen in years, he described it as “an open-source decentralized internet project,” and that it “would give control of computing back to regular people.” That sparked my interest, but I didn’t totally understand it. After looking over the website and watching a couple of obscure descriptive videos on YouTube my response was threefold:
20+
21+1) **This is huge** — if it actually works, it’s the future.
22+2) **This is real** — It’s got working code, dozens of engineers, and a very unorthodox solution.
23+3) **I don’t truly understand this** — I can’t read the code, and I can barely comprehend the paradigm shift.
24+
25+So of course I asked for an intro.
26+
27+Fast forward: I ended up becoming COO at Tlon, the primary developer of Urbit. Urbit is exactly the sort of project I was looking for — one that represents an important promise for humanity. But, boy, did I have to fake my way through the technical elements of my new job those first few months.
28+
29+What I eventually came to realize is that if Urbit is only accessible to programmers, it’s dead on arrival. In order to be useful, Urbit has to be understandable by the non-technical user. Like me. And maybe like you.
30+
31+I understand as well as anyone how complicated Urbit can appear. But, fundamentally, Urbit is quite simple and it promises a critical upgrade to human interaction. That might sound like hyperbole but it’s the reason I work here. This is my attempt to explain to fellow normies the scope and scale of this world-changing project called Urbit.
32+
33+
34+## What is Urbit?
35+
36+Let’s take this one step at a time and start with the most basic definition:
37+
38+Urbit is a peer-to-peer internet being built from scratch to be more private, secure, and durable than the current internet.
39+
40+At its most basic level, an Urbit is:
41+
42+1) A super-private computer, combined with
43+2) an ID, which is
44+3) connected peer-to-peer with other Urbit computers.
45+
46+Taking that a half-step deeper, each Urbit user gets a permanent identity, which allows them to access their personal computer in the cloud, and then talk to directly with other Urbit computers (i.e. other people) on the network, all without using an intermediary.
47+
48+When I say “computer” I’m not talking about a physical device, but rather the software that computes. Urbit is a virtual computer, not a hardware device. Today that means you can access your Urbit computer from anywhere, on just about any device with a web browser. Eventually you won’t even need the web browser.
49+
50+By “intermediary” I’m talking about all those centralized servers that we use every day to do our computing. Servers owned by Google, Facebook, YouTube, Instagram, Twitter, Slack, Amazon, Nest, Apple, and so on. All of these companies and products keep close tabs on our activity and use that information to sell us things and influence our opinions. Everything we do online is watched and recorded.
51+
52+Urbit will fundamentally change that — more about the privacy implications later.
53+
54+<img class="ba" src="https://media.urbit.org/site/posts/essays/normies-1.png">
55+
56+## What it looks like
57+
58+Another way of explaining Urbit is to describe how it feels and looks. Visually, Urbit belongs to a genre often called “calm computing.” Urbit is designed to be simple, basic, and non-addictive. You won’t find any flashy-blinky lights here; no zany colors; no wacky branding. Just calm, functional, purpose-built tools for people to connect and work together. (One of my favorite examples of calm computing is the [light phone](https://www.thelightphone.com/).)
59+
60+Today Urbit’s interface looks like a tab in your web browser that has some limited functionality (chat, a weather app, a notebook, link sharing). Soon, you won’t even need the web browser — you’ll be able to access or run Urbit directly in its own window. Inside will be a super clean interface with all the functionality you might want from your computer, in one place and with one login (think document creation, email, social media access, accounting) — but it will run on your virtual Urbit computer, so it will be safe from corporate prying and data leaks, available on any device, and all inside one simple interface.
61+
62+## What it’s for
63+
64+Fundamentally, Urbit is neutral open-source infrastructure, so it can be for many things. From our highest level perspective Urbit is computing for real communities and normal people, not for corporations. To make that real, Urbit focuses on delivering a computing experience that is secure, private, durable, and calm.
65+
66+For me, Urbit’s core purpose is to give us all back our privacy and our autonomy. It’s time for humanity to control its tools rather than the other way around.
67+
68+## Key elements
69+
70+One potential barrier to understanding Urbit is that we’re building out multiple layers of this new internet simultaneously, and each has its own explanations and value propositions. Remember, what sets Urbit apart is that we’re building of all these elements at once to work together as a system.
71+
72+I’ll try to explain the most important of these without straying too deep into the technical weeds.
73+
74+1. **A peer-to-peer network**
75+
76+ Peer-to-peer networking is a really big deal. On the current internet, essentially all of our communications and activities go through centralized servers owned by corporations (Facebook, Google, etc.) — and those corporations can’t help but use all that information to make money. They’re capitalists, after all, and so we get constant privacy violations and interfaces built for maximum dopamine addiction.
77+
78+ In an Urbit world, all those communications go directly between users (i.e. peer-to-peer) with nobody in the middle. That means there’s no data capture by any megacorp, less intrusion into your life online, and communications go back to the semi-private one-to-one or small group format that is most comfortable for humans. It’s more like real life.
79+
80+2. **Your own server**
81+
82+ Servers are complicated. Too complicated. Have you ever tried to use a command line? Exactly. It’s a terrible way to work, and that’s just a hint at how complex servers are to operate. To hide that complexity, we let corporations run our servers for us — they can afford teams of engineers. The problem is that today most of our computing is handled by these corporate servers — and that means we’re giving up control because of complexity.
83+
84+ As an example, every time you use Siri, your message is sent to Apple’s servers, where it is processed, and the response is sent back to you (which is admittedly amazing). Unfortunately that’s why it never works if you’re offline, and it’s also why Apple knows what you’re saying to Siri. And this applies to all the apps we use: The actual computing happens on corporate servers. The problem is that we consumers aren’t in control and, again, the corporate entities watch, record, and gate-keep all of our activity.
85+
86+ Fundamentally, Urbit is a super simple server. That means Urbit can run those computations and hold all that data for you, eliminating the need for a corporate intermediary.
87+
88+3. **Permanent, personal ownership of your digital identity and all your data**
89+
90+ Urbit IDs are permanently ownable — and that ownership is backed by cryptography, not some corporate database. Once you take possession of your Urbit ID, no central authority can ever take it away from you. Sure, if you start spamming people on the network, word could get around and you might get blocked by other users, but none of them can prevent you from using your ID or accessing your Urbit computer. Compare that to the current internet where Facebook owns your Facebook profile, Google owns your Gmail account, Twitter owns your Twitter handle, etc. At any time and for any reason, those services can arbitrarily shut off your access, and you have little to no recourse — all that data, all those followers, and all that reputation is wiped out instantly. Your Urbit, on the other hand — both the identity, and all the data inside your Urbit computer — is yours permanently, so long as you know your secret key.
91+
92+ A secure decentralized identity system like the one we’ve built leads to some very interesting use cases that are otherwise insurmountable. For example: decentralized Uber, decentralized delivery services, and a solid solution to the problem of fake reviews. To build any of these services, the problem of permanent identity needs to be solved first, and we’ve done that as part of our overall system. I’ll spend more time on use cases below.
93+
94+ It’s worth noting that this problem has never been solved before. All of our communication channels on the internet today rely on someone else to authenticate our identity. Urbit is — to my knowledge — the first practical application of a decentralized ID system that actually works.
95+
96+4. **An incentive for good behavior**
97+
98+ On the Urbit network, identities are finite, and they accrue reputation. Compare that to the current internet where identity is infinite (anyone can create as many email addresses or social media profiles as they want, essentially for free) and so spam, scams, and DoS attacks (“denial-of-service”: when many disposable identities ‘attack’ a server at the same time) are rampant. On the Urbit network, there are just over 4 billion total IDs (2<sup>32</sup> to be exact). Scarcity creates value. That scarcity, combined with reputation accrual, means there's an incentive for good behavior.
99+
100+ You might think 4 billion IDs sounds like too few given how many humans we have on the planet. I won’t go into the technical details here, but if we ever get to the point where that’s a problem (which would be a great problem to have), we’ve outlined several solutions that allow everyone alive to get on the network. We don’t intend to lock anyone out.
101+
102+5. **Tools anyone can learn and use**
103+
104+ Urbit is a system that anyone with patience can understand completely from top to bottom, from the integers of byte code to the complete OS and everything in between. Urbit in its entirety is just over 50,000 lines of code. That is tiny. Compare that to Linux (the open-source OS that most modern computing is built upon), which is tens of millions of lines of code, and you start to see how important this is for efficiency. Apple’s and Windows’ codebases are similarly massive. In our current computing system, nobody can understand the entire thing completely, and that means there are innumerable security holes. With Urbit, while it may demand something of you, any reasonably intelligent developer can grasp the whole thing. We’ve worked very hard to keep our system simple at each level. That makes it more efficient, more durable, and much more secure.
105+
106+6. **Lessons from the last half century**
107+
108+ Bear with me — this is where some jargon kicks in. In many ways, Urbit is an attempt to apply lessons learned from the failures of 20th century computer development. From an engineer’s perspective, Urbit solves a series of problems that we end users rarely notice, but which cause extraordinary amounts of complexity and waste. The list of applied lessons is long, but rather than bullet them all, I’ll explain the one that surprised me the most.
109+
110+ Urbit is deterministic. That is, a given sequence of inputs always produces the same output. When I first heard that, I thought, “Wait, isn’t that what all operating systems do? Give you the same result every time?” Weirdly, the answer is no. Normal operating systems don’t work this way. Normal modern operating systems actually get varying results when they compute things. This is a deep problem that causes programmers countless hours of frustration. The most common implication of this that you’ve probably experienced is having to reboot your computer — either because it’s locked up, or because it simply won’t do something that it was totally doing a second ago. What’s annoying to a regular user, though, is absolutely crazy-making to developers.
111+
112+ This determinism makes programming on an Urbit immensely more efficient than other environments.
113+
114+ Urbit applies this and a whole list of other lessons from the past half-century of systems software to increase reliability and security in everything from file storage to networking to user-facing apps. All this adds up to more security and reliability and less service-lock-in with Urbit than with our current systems.
115+
116+7. **Private, human-sized, and efficient**
117+
118+ Because Urbit isn’t centralized or owned by any one company, there’s no incentive for it to dominate your life. Your Urbit isn’t designed to spy on you, get you addicted to clicking its buttons, manipulate your emotions to gain attention, or nudge you to buy something. Your Urbit is a simple, customizable, permanent place for you to do all your computer-based tasks with your friends in absolute privacy.
119+
120+ This is so much the case, in fact, that it presents a bit of a problem for Tlon. We don’t know how many people use Urbit every day, who they talk to, or what they’re doing. While we think this is how things should be, it puts us in a bind when a VC wants to know about our user base; we can only make educated guesses. That said, we think this is the right problem to have.
121+
122+ What all this adds up to is that the Urbit network is immensely more resource efficient, secure, easier to customize, and smaller in size than any other computing system in the world. If you care about data security, privacy, durability, or even just elegance, Urbit has the best design going.
123+
124+ <br></br>
125+
126+<img class="ba" src="https://media.urbit.org/site/posts/essays/normies-2.png">
127+
128+## How it compares
129+
130+A final way to understand Urbit is to make comparisons between Urbit and current products we use today. This is limited, because ultimately Urbit will grow in directions we can’t predict, but comparisons are a useful starting place.
131+
132+Again, on the current internet, we all access megacorp software using our web browsers and app interfaces. This means that we each exist as a line in a megacorp database, and those megacorps use that data to make money, which results in rampant privacy violations and addictive interfaces. Urbit is the alternative to all that: it’s decentralized, private, and secure. And it’s yours.
133+
134+Let’s get to some real-world examples.
135+
136+
137+## Urbit vs. Reddit
138+
139+Imagine you’d like to discuss a certain research topic with a group of friends. Say, Canadian small cap equities or the best cookie recipes. You’ll need a chat interface for live discussion, a notebook to record concepts, and a way to share links for discussion. You can do this in the default web if you want: use Reddit for the links (but make sure it’s a private group), use Google Docs for the notebook (but make sure everyone has Gmail), and use iMessage for the chat (but everyone needs a Mac). And don’t forget, each service has their own login and security holes, and they’re all mining your data.
140+
141+The alternative is spin up a group on Urbit. All of that functionality is available today in one clean, simple interface. It’s private, you own the data, there’s only one login, and you can even learn to build apps for your group.
142+
143+## Urbit vs. Facebook, Twitter, etc.
144+
145+Or let’s say you want to share pictures with your friends, post micro-messages to the world, write a blog, or share a podcast. There’s simply no reason you should use some centralized company (one that then owns your content) to broadcast any of those things. Instead, send it out from your Urbit. You’ll own the content, you’ll control the data, no company will spy on you, and nobody can ever take your ID from you. With Urbit we all finally own the tools, and that means we own the data by default.
146+
147+## Urbit vs. Nest
148+
149+Imagine, as I do, that you want a connected video camera in your house, but don’t want the Nest corporation (which is now owned by Google) to be able to spy on you. Or perhaps you just don’t want to have to sign up for yet another duplicative service in order to use the camera you just bought. If any of that is the case, you can run your camera through your Urbit instead. The video feed will never leave your control, because it no longer has to live on Nest’s servers. Your camera will talk over a secure channel only to your Urbit. Your Urbit is the server.
150+
151+You can apply this same concept to smart speakers, a Ring doorbell, connected baby monitor, smart fridge, or any of the innumerable connected devices that give someone else access to your personal life. Why should anyone else have access to that information?
152+
153+## Urbit vs. Google Docs
154+
155+Imagine you want to write a screenplay with a small group of friends, but you don’t want Google mining the content of your shared doc for advertising keywords, and you won’t want to use multiple services for chat, document sharing, email, etc. In that case, simply create an Urbit group with your friends and write together using Urbit’s writing tools. Your content will stay completely private to the team until you decide to release it to the world, and you’ll communicate using one simple interface. Even better, the archive of your multimodal work lives in one place, so looking back at your process doesn’t require reconstructing it from dozens of different apps. And everything is stored on your respective Urbit computers, not Google’s servers.
156+
157+## Urbit for your protected health information
158+
159+Imagine, as is already becoming the case, that it becomes highly valuable to have your genome sequenced in order to make good healthcare decisions. In that scenario, most of us would want our health care providers to be able to make precise assessments of parts of our genome, but we wouldn’t want insurance companies or other third parties to have access without our permission. In the current paradigm, once you share the information, it’s out there and can be leaked or sold. So much so that we all sort of assume that leaks are the default. In the Urbit paradigm, that information lives on your Urbit computer and nowhere else, and any software necessary to process it can be run on your Urbit as well. In other words, there’s never any need to share the raw data with anyone; instead, you can download a small program, run it on your Urbit, and share the final analyses only without ever exposing your data.
160+
161+Some of these cases are, admittedly, a bit speculative since we haven’t built all the functionality yet. But it’s coming, and quite soon.
162+
163+For now, if you like the way this sounds you can [get yourself an Urbit ID](https://urbit.org/using/install/#id) and start learning about how to safely store cryptographic keys (it’s really not that hard, and we give you suggestions). If you’re feeling technical or adventurous, you can try booting our beta OS interface to see what it looks like. It’s fussy, but it exists. Soon it will be less fussy. You can check out our [roadmap](https://urbit.org/understanding-urbit/roadmap/) if you’d like to know when.
164+
165+## Why we need Urbit
166+
167+We humans haven’t evolved enough to manage the firehose of information that modern technology blasts us with. There’s too much news, too many connections, too many opinions, and more agendas out there than any of us can mindfully comprehend. We’re designed for much smaller communities, one-to-one connections, and slower idea assimilation than our modern infrastructure allows. The pace of change is increasing, and we don’t know how to manage it.
168+
169+We’re scared, and to manage that fear we’re becoming more insular, more entrenched. Layer on top of all that the incentives that big business and big politics have to manipulate our emotions, and we’re headed in a very dangerous direction.
170+
171+We can’t turn back the technological clock; humanity can only ever press onward. This is where Urbit comes in. Urbit is a forward-looking solution to this particular set of problems around human-scale computing and personal autonomy. Urbit provides a means by which groups can live peacefully in parallel.
172+
173+Urbit is a computing environment that allows humans to do everything they want on computers, but in communities of their choosing, in a way that feels direct and natural, and in a way that allows true personal freedom. Urbit is calm, secure, and private in its most fundamental architecture. No spying corporations. No manipulative politicians.
174+
175+And that is what we need. Humans need a way to at once take advantage of our vast technological advances but not be dominated by them. Urbit is an open-source tool that we all own, that anyone can understand down to its roots, that’s fully under its user’s control. It is human-scale computing for human-scale communities. Simple, durable, yours.
176+
177+For me, this first iteration of Urbit is more than enough, and it’s exactly the sort of peaceful future I want to work towards.
content/understanding-urbit/your-last-computer.md → content/blog/your-last-computer.mdrenamed+2−5
@@ -1,11 +1,8 @@
11+++
22title = "Your Last Computer"
3−description = "What Urbit should feel like to an everyday user"
4−weight = 2
3+date = 2019-10-17
4+description = "Your Urbit is a simpler computer, a quieter computer, a more private computer. We want it to feel predictable, safe, and reliable — things only a complete, sealed system can do. This, we hope, can get us a world where technology keeps us connected, but doesn’t dominate our lives."
55[extra]
6−flatten_pagination = "true"
7−hide_next_title = "true"
8−hide_previous_title = "true"
96image = "https://media.urbit.org/site/understanding-urbit/your-last-computer/your-last-computer-waves%402x.png"
107+++
118
content/community/governance.md+2−3
@@ -4,7 +4,6 @@ description = "On the governance of the project, including both the senate of ga
44aliases = ["/governance"]
55weight = 4
66[extra]
7−hidetitle = "true"
87hideprevious = "true"
98hidenext = "true"
109+++
@@ -19,8 +18,8 @@ In a similar process, document hashes can be proposed. While their off-chain doc
1918
2019For off-chain process around proposals, as suggested by core developers, please see [senate.md](https://github.com/urbit/azimuth/blob/master/senate.md).
2120
22−The group of core developers manages Urbit’s [GitHub repository](https://github.com/urbit/), which controls Arvo, Urbit’s operating system. Changes and upgrades are decided upon by consensus.
21+The group of core developers manages Urbit’s [GitHub repository](https://github.com/urbit/), which controls Arvo, Urbit’s operating system. Changes and upgrades are decided upon by consensus.
2322
24−You can participate in the governance of the senate by acquiring a galaxy. If you would like to be involved with the governance of Arvo, check out our [developer guide](@/using/develop.md) to learn how you can contribute to core development.
23+You can participate in the governance of the senate by acquiring a galaxy. If you would like to be involved with the governance of Arvo, check out our [developer guide](@/using/develop.md) to learn how you can contribute to core development.
2524
2625
content/community/hoonschool.md+1−1
@@ -22,4 +22,4 @@ Hoon 101 is a six-week, introductory-level course. It’s appropriate for motiva
2222
2323We're in the process of designing advanced Hoon Courses, but they aren't ready yet. They'll cover advanced development with Hoon, such as app development, kernel development, and the details of the Hoon type system. Such classes will be appropriate for graduates of Hoon 101. Check back later if you're interested in enrolling.
2424
25−<script class="src="https://static.airtable.com/js/embed/embed_snippet_v1.js"></script><iframe id="apply" class="airtable-embed airtable-dynamic-height w-full" src="https://airtable.com/embed/shr8bb15QPR3hfQpG?backgroundColor=teal" frameborder="0" height="1300"></iframe>
25+<iframe id="apply" src="https://docs.google.com/forms/d/e/1FAIpQLSdcEoEqpFvB1WCTKPaYUSbJcjQ2nHk_z4XcZPIQc0SFD1rgmA/viewform?embedded=true" width="640" height="1350" frameborder="0" marginheight="0" marginwidth="0">Loading…</iframe>
content/community/hosting-a-meetup.md+7−9
@@ -14,7 +14,7 @@ There are already [a few](../meetups) Urbit meetups that take place in cities ar
1414
1515The most straightforward way to start a meetup group online, like on [meetup.com](www.meetup.com). Services like this offer messaging, calendaring, payments, discussion boards, and basic group profiles.
1616
17−There are other options available but, regardless of what you choose, there should be a public place on the web for people to access the group.
17+There are other options available but, regardless of what you choose, there should be a public place on the Web for people to access the group.
1818
1919Group suggestions:
2020
@@ -24,7 +24,7 @@ Group suggestions:
2424
2525### Spread the word
2626
27−It’s not much fun if people don’t actually show up, so it’s important to get the word out. Use your existing network to tell people about your event. Remember it takes time to build a community, so don’t be discouraged if only a few people show up at your first event. Also, be sure to email [support@urbit.org](mailto:support@urbit.org), and we'll promote your meetup.
27+It’s not much fun if people don’t actually show up, so it’s important to get the word out. Use your existing network to tell people about your event. Remember it takes time to build a community, so don’t be discouraged if only a few people show up at first. Post to social media and email your friends. Also, be sure to email [support@urbit.org](mailto:support@urbit.org), and we'll promote your meetup.
2828
2929Outreach methods:
3030
@@ -36,9 +36,7 @@ Outreach methods:
3636
3737Meetups are about sharing ideas and meeting like-minded people. There are a few formats that can help achieve this goal. As the organizer, take the lead and prepare ahead of time. Think of some topics for the group to discuss, and try to ensure that the conversation isn’t dominated by one or two people.
3838
39−Presentations are a great way to share ideas. If you have a speaker for your event, coordinate ahead of time and make sure they have everything they will need to make a great presentation and ask them to arrive early to the event.
40−
41−If you have a speaker, be sure to record the talk so that it can be posted online. There are plenty of people who would appreciate such content.
39+Presentations and guided group discussions are great ways to share ideas. If you have a speaker for your event, coordinate ahead of time and make sure they have everything they will need to make a great presentation and ask them to arrive early to the event. If you have a speaker, be sure to record the talk so that it can be posted online.
4240
4341Format considerations:
4442
@@ -47,7 +45,7 @@ Format considerations:
4745
4846### Venue
4947
50−Your meeting location can determine the success of your event. Consider how your members might get to the venue. Ideally, you’d want to be away from congested areas and find locations with good parking and transit options nearby. However, this isn’t always possible, so just do your best to accommodate. It’s also a good idea to locate the event near bars or restaurants so people can continue the conversation after the event officially ends.
48+Your meeting location can determine the success of your event. Ideally, you’d want to be away from congested areas and find locations with good parking and transit options nearby. However, this isn’t always possible, so just do your best to accommodate. It’s also a good idea to locate the event near bars or restaurants so people can continue the conversation after the event officially ends.
5149
5250Location considerations:
5351
@@ -55,11 +53,11 @@ Location considerations:
5553- Consider parking and distance to transit
5654- Check out public libraries
5755- Coworking spaces
58−- [peerspace.com](www.peerspace.com)
56+- [peerspace.com](https://www.peerspace.com/)
5957
6058### Date and time
6159
62−Most people are able to attend meetups after work on weekdays. This isn’t true for everyone but it’s a good rule of thumb. It’s also a good idea to avoid holidays and days when there are large sporting events happening.
60+Most people are able to attend meetups after work on non-holiday weekdays, between about 6-8pm. This isn’t true for everyone but it’s a good rule of thumb. It’s also a good idea to avoid holidays and days when there are large sporting events happening.
6361
6462Date considerations:
6563
@@ -69,7 +67,7 @@ Date considerations:
6967
7068### Stay consistent
7169
72−Like anything worth doing, meetups take time, patience, and consistency. Come prepared to engage with people and have a good time. The more often you can meet the stronger the community can become, so schedule meetups regularly.
70+Like basically anything worth doing, meetups take time, patience, and consistency. Come prepared to engage with people and have a good time. The more often you can meet the stronger the community can become, so schedule meetups regularly.
7371
7472### Bonus
7573
content/community/meetups.md+3−1
@@ -34,9 +34,11 @@ Copenhagen, DK | [Twitter](https://twitter.com/UrbitCPH), [Meetup.com](https://w
3434
3535Location | Contact information
3636:------------ | :-------------
37−Phoenix, AZ | [Twitter](https://twitter.com/UrbitPHX)
37+Phoenix, AZ | [Twitter](https://twitter.com/UrbitPHX), [Meetup.com](https://www.meetup.com/urbit-phx/)
3838San Francisco, CA | [Meetup.com](https://www.meetup.com/urbit-sf/)
3939New York, NY | [Meetup.com](https://www.meetup.com/Urbit-New-York/)
40+Toronto, ON | [Twitter](https://twitter.com/UrbitToronto), [Meetup.com](https://www.meetup.com/Urbit-Toronto/)
41+Eugene, OR | [Twitter](https://twitter.com/EugeneUrbit)
4042Austin, TX | [Meetup.com](https://www.meetup.com/Urbit-Austin/)
4143Denton, TX | [Twitter](https://twitter.com/UrbitDFW)
4244Seattle, WA | [Meetup.com](https://www.meetup.com/urbit-seattle/)
content/docs+1−1

Submodule changed.

content/faq.md+15−11
@@ -319,47 +319,51 @@ You must complete the proposal to be guaranteed to receive the star grant. Parti
319319
320320However, either party may terminate a proposal on seven days’ written notice. In such a scenario, you may be paid pro rata for any portion of the proposal that has been completed.
321321
322−### Do I have to pay taxes on stars? {#grant-5}
322+### Do star rewards from grants have lockup conditions? {#grant-5}
323+
324+No.
325+
326+### Do I have to pay taxes on stars? {#grant-6}
323327
324328Yes. In the United States, stars are considered to be income. If you are American, we need your W-9 before we can pay out your stars. If you’re not an American, you don’t need to get us any forms, but you do need to personally follow the relevant tax laws in your jurisdiction.
325329
326−### Can I create a bounty? {#grants-6}
330+### Can I create a bounty? {#grants-7}
327331
328332No. Bounties are only created by Tlon, but we draw inspiration for bounties from various sources, including the community. If you want to pitch a project, use the Proposals system.
329333
330−### How are proposals approved? {#grants-7}
334+### How are proposals approved? {#grants-8}
331335
332336The manager of the Grants program approves them after consulting with the relevant members of the engineering team. This proposal can be accepted, rejected, or accepted with changes by Tlon. The proposal’s star payout can also be adjusted.
333337
334−### If I win a proposal, do I have an exclusive claim on the project? {#grants-8}
338+### If I win a proposal, do I have an exclusive claim on the project? {#grants-9}
335339
336340You have a claim to the reward of the project as long as milestones are met to the satisfaction of Tlon. However, Tlon may allow another developer to work on the same project in parallel, for a separate reward.
337341
338−### Will milestones be embedded in a smart contract? {#grants-9}
342+### Will milestones be embedded in a smart contract? {#grants-10}
339343
340344No.
341345
342−### Does reputation play a role in the assessment of grants? {#grants-10}
346+### Does reputation play a role in the assessment of grants? {#grants-11}
343347
344348Yes. We consider this to be a feature.
345349
346−### I completed a proposal. When will I receive payment? {#grants-11}
350+### I completed a proposal. When will I receive payment? {#grants-12}
347351
348352We will pay you within a 30-day window.
349353
350−### Can I see the proposals of others that have been accepted? {#grants-12}
354+### Can I see the proposals of others that have been accepted? {#grants-13}
351355
352356Yes. Check out our [proposals page.](https://grants.urbit.org/proposals)
353357
354−### How do I safely store my stars? {#grants-13}
358+### How do I safely store my stars? {#grants-14}
355359
356360We recommend storing each star in its own Ethereum wallet. The private keys to these wallets should be stored on physical media that is not connected to a networked computer. Redundancies don’t hurt!
357361
358−### Can I delegate a bounty or proposal to someone else? {#grants-14}
362+### Can I delegate a bounty or proposal to someone else? {#grants-15}
359363
360364No, not unless explicitly authorized by Tlon.
361365
362−### Do I need to sign a contract? {#grants-15}
366+### Do I need to sign a contract? {#grants-16}
363367
364368After you are approved to work on a bounty or a proposal, you will be sent a contract that you'll need to sign. You don't need to sign a contract to receive a gift, though.
365369
content/understanding-urbit/interface.mdnew file+63
@@ -0,0 +1,63 @@
1++++
2+title = "Interface"
3+description = "What Urbit feels like to an everyday user"
4+weight = 3
5+[extra]
6+flatten_pagination = "true"
7+hide_next_title = "true"
8+hide_previous_title = "true"
9++++
10+
11+We started at the bottom of the stack, years ago, with the VM. We’re just now getting to the top: the interface. Urbit ID and Urbit OS are great tools — but technology on its own isn’t enough. As far as we’re concerned, if people don’t actually use this thing, it doesn’t matter.
12+
13+Urbit, VM to UI, is meant to feel like the a desktop OS for a networked world: a single, unified system where you can interact with, update and archive all of your personal data; communicate with your friends and family; and collaborate with the people you work with.
14+
15+One way to imagine Urbit is as the Western answer to WeChat: a seamless, multi-purpose, vastly extensible social network, but without the surveillance. As a platform anyone can extend, we see Urbit as the ultimate productivity tool: no more frankenstack of apps and services needed for companies and collaborators, because everything lives in one interface. With the power to build whatever you want on top of Urbit, you can bring everything together in one place.
16+
17+In early 2020, we’ll release what we’re calling OS 1 — the first minimal but complete user experience for Urbit. OS 1 brings together the whole Urbit stack into a single interface. OS 1 is simple in the extreme. It’s a calm, ad-free, privacy-respecting environment to homestead new digital communities.
18+
19+We’ve got a pretty clear picture of OS 1, 2 and 3 which we’ll explain in [the roadmap](/understanding-urbit/roadmap). Here, we’ll focus on the vision for Urbit as a user experience.
20+
21+<img class="full w-100 mv4" src="https://media.urbit.org/site/understanding-urbit/project-history/uu-osn-1.svg"/>
22+
23+In the current world of apps and services, there’s no operating system in any meaningful sense. Our laptops and phones just let us switch between services. Our communities, co-workers and lives are spread between these services — and the work of combining them is left to the user. You have to remember all your passwords, who sent what message where, what files are on which platform, and so on.
24+
25+The most severely lacking thing about our digital lives today is that they lack a sense of place or a sense of home.
26+
27+It’s annoying and confusing to switch between interfaces, you can’t extend or build on top, and privacy and security are out of your hands. This fragmented, siloed, closely surveilled experience is simply a byproduct of having other people run and control your software. The result, for the ordinary user, is restrictive and boring. The possibility for everyday creativity with the tools we’re stuck with is close to zero. Wasn’t the computer supposed to be a bicycle for the mind?
28+
29+Operating systems for the PC took the desk of the 1970s and made it digital. Paper, drawers and envelopes became ‘files’ and ‘folders’. It’s a great abstraction, but it’s ancient. We live in a multiplayer, connected world; we need an operating system that knows that.
30+
31+The ‘desk’ of today is cluttered with apps and services, data structures and interfaces. Refactoring this, unifying it, is the most important problem that a platform like Urbit can solve. We want Urbit, as a user experience, to be a single system for bringing together a group of people to do many things together.
32+
33+<img class="ba" src="https://media.urbit.org/site/understanding-urbit/your-last-computer/your-last-computer-waves%402x.png">
34+
35+What exactly does this look like? In the long run, we’re not 100% sure. There’s a lot to be invented — but we have a first pass that we think is quite good. At least, good enough that we like using it quite a lot.
36+
37+In Urbit, there are two building blocks: groups and modules. A group is exactly what it sounds like: 1 or more people. A module is sort of like an app without the data lock-in. It’s just a tool for getting something done, like ‘chat’, ‘publish’, or ‘links’ that’s shared by a group. Any group on Urbit can combine modules, or build their own.
38+
39+Think of a module like a particular way of communicating. Usually, groups have a few different ways they want to communicate. Urbit makes this simple and straightforward. With one group, you may decide to chat and share photos. Another might share annotated research, watch the markets, and manage payments on a blockchain.
40+
41+Creating a group and customizing the modules it shares is easy. Building a new module is pretty straightforward as well, no more difficult than building an iOS app — although you do have to learn about the Urbit stack.
42+
43+<img class="full w-100 mv4" src="https://media.urbit.org/site/understanding-urbit/uu-osn-3.svg"/>
44+
45+We think this basic metaphor can scale, over time, to be useful in many different contexts.
46+
47+For example, parents might give their young children an Urbit that’s locked, at first, to only two groups: family and friends from school. It might also be limited to one module: chat.
48+
49+A broader group of siblings, parents and grandparents might create a group with a few more modules to share photos, chat and coordinate events.
50+
51+A new tenant in a building could use an Urbit workspace to lock and unlock doors, pay their utilities and rent, and communicate with the landlord. The building owner could use an Urbit workspace to keep up with all her tenants, accept rent payments, check on critical building systems and communicate with subcontractors.
52+
53+This model provides for unending possible combinations for ordinary users, without increasing complexity for developers. It’s clear to us what this can look like in the short term. What the zoomers will do with it is beyond our imagination.
54+
55+<img class="full w-100 mv4" src="https://media.urbit.org/site/understanding-urbit/uu-osn-4.svg"/>
56+
57+Centralized services are great at replacing broadcast media: distributing content from a producer to a bunch of followers.
58+
59+Urbit is for everything else. That is, Urbit is for actual two-way communication: keeping a group of friends connected, staying in touch with your family, or working with a group of collaborators.
60+
61+We designed Urbit to become the best tool for communicating with friends and family, or collaborating with peers. It’s a social network, but much calmer and more purposeful. It’s a productivity tool, but much more secure and powerful.
62+
63+How do we get to this future? By staying focussed, writing code, and iterating through design. We have a rough outline of this process — let’s walk through it.
content/understanding-urbit/network-and-os.mddeleted−40
@@ -1,40 +0,0 @@
1−+++
2−title = "Urbit OS + Network"
3−description = "The Urbit OS + Network + how they work together"
4−weight = 5
5−[extra]
6−flatten_pagination = "true"
7−hide_next_title = "true"
8−hide_previous_title = "true"
9−image = "https://media.urbit.org/site/understanding-urbit/network-os/urbit-os-phones@2x.png"
10−+++
11−
12−
13−
14−Our phones are cluttered with apps, ads, and notifications. Our laptops are basically just web browsers that connect us to services controlled by MEGACORP. Who knows where your messages, images, contacts, and connections live, let alone how long they’ll last or who is looking at them?
15−
16−<img class="mv5 w-100" src="https://media.urbit.org/site/understanding-urbit/network-os/urbit-os-phones%402x.png">
17−
18−The digital world feels like a theme park built to maximize ENGAGEMENT — but we think it’s BORING. What happened to the vision of a computer as a tool that would expand and enrich our lives?
19−
20−While the world has drifted into a fever dream, we built Urbit.
21−
22−<img class="mv5 ba w-100" src="https://media.urbit.org/site/understanding-urbit/network-os/urbit-os-diagram.svg">
23−
24−Your Urbit ID gets you a name, an address, and a crypto wallet — but what about when you want to connect with other people? That’s where Urbit OS comes in.
25−
26−Urbit OS is everything that you need to build and run your own social software and compute with whomever you like. Create a pseudonymous chat group, edit a document together, then split a bar tab and later turn it into a syndicate and start investing. Eventually, maybe you’ll decide to become a microstate that funds everyone in Bitcoin — the possibilities are wide open.
27−
28−Since we’ve got a decentralized identity system to build on and everyone runs their own OS, your social software is actually owned and operated by the collective of Urbit ID owners. You can (and should) do whatever you want.
29−
30−<img class="mv5 ba w-100" src="https://media.urbit.org/site/understanding-urbit/network-os/urbit-os-diagram-apart.svg">
31−
32−We built Urbit OS from scratch. It’s a completely new computing stack. Without getting into the technical details (you can find those [here](@/understanding-urbit/technical-overview.md)), Urbit OS is built to do three things: be a compact and complete system (simple); run forever with no maintenance (durable); and be extensible by anyone (yours).
33−
34−Urbit OS is a completely unified system with no external dependencies. In a single codebase, two orders of magnitude smaller than Linux, you have an entire programming language and operating system. We realize how crazy this is — but it means that a single person can actually understand the entire system. Who is the last person you met that actually understands their entire computer? Urbit OS is like the [1968 Porsche 911](https://cdn.bringatrailer.com/wp-content/uploads/2007/05/1968_Porsche_911_SR_Factor_Race_Car_Engine_1.jpg) of operating systems.
35−
36−At the very bottom of the stack, Urbit OS is just a single, fixed function that we never change. Everything on top is upgradeable over the network. This means your Urbit OS can run forever without you ever having to do any maintenance. Put it on a USB stick, throw it in a drawer for ten years, and forget about it. When you plug it in again, it’ll upgrade itself automatically.
37−
38−Since Urbit OS is completely sealed, it’s all run-from-source. All the code to run the system is yours to modify, tinker with, and extend. Build your own apps, modules, and user experience. Or customize Urbit OS to control your tractor. Even better: collaborate with others on the network to build the experience you’re looking for. It’s entirely up to you.
39−
40−We build Urbit OS so we can finally have a dependable system that we can commit to and keep far into the future. The modern web already looks dated to us.
content/understanding-urbit/people-history.mdnew file+104
@@ -0,0 +1,104 @@
1++++
2+title = "People + History"
3+description = "Where we've been and were we are now"
4+weight = 5
5+[extra]
6+flatten_pagination = "true"
7+hide_next_title = "true"
8+hide_previous_title = "true"
9+image = "https://media.urbit.org/site/understanding-urbit/project-history/project-status-landscape-earth%402x.png"
10++++
11+
12+So who builds this thing? Where does it come from? What’s the history?
13+
14+Today, Urbit is built and maintained by two companies, a community of contributors and core developers, infrastructure (star) operators, and governance (galaxy) node owners.
15+
16+Let’s talk first about these individual groups within the Urbit community, then about the history of the project and how it came to be.
17+
18+<img class="ba" src="https://media.urbit.org/site/understanding-urbit/project-history/project-status-landscape-earth@2x.png">
19+
20+There are currently two independent companies that work on building Urbit full-time: [Tlon](https://tlon.io/) and [urbit.live](https://urbit.live/).
21+
22+Tlon has been around since 2013 or so, and is primarily focussed on the development of Urbit OS and its user experience. Urbit.live was started in 2018 to make the onramp into Urbit as easy as possible. Both companies contribute regularly to the code base.
23+
24+Tlon was originally granted about half of the Urbit ID address space, and has used that to fund its operations so far. Over time, Tlon plans to offer hosting and services to make using Urbit as easy as possible.
25+
26+Tlon is also working to set up an urbit.org foundation. This is still in process, and is expected to happen in 2020.
27+
28+Urbit.live started selling Urbit IDs very early once that became possible, and also plans to offer services within the Urbit ecosystem.
29+
30+The community of contributors and core developers has been steadily contributing to the code base since before Tlon existed, and they’re still going strong. They can primarily be found on Urbit itself, in `~dopzod/urbit-help`, the [urbit-dev mailing list](https://groups.google.com/a/urbit.org/forum/#!forum/dev) and on [GitHub](https://github.com/urbit).
31+
32+When the Urbit ID address space went on-chain in early 2019 there were about 2,000 star holders and 70 galaxy holders – that number has since grown steadily. For the most part, the best way to connect with them is through Urbit itself.
33+
34+<img class="ba"
35+src="https://media.urbit.org/site/understanding-urbit/uu-people-history-2a.jpg"/>
36+
37+<img class="ba"
38+src="https://media.urbit.org/site/understanding-urbit/uu-people-history-2c.jpg"
39+/>
40+
41+Given how new and unusual Urbit is, it attracts a wide variety of interesting people — both technical and non-technical. The community is generally happy to talk to people about what Urbit is, what we’re up to, and where we’re going. The best way to get involved is to simply join `~dopzod/urbit-help` — which our [setup instructions](/using/operations/using-your-ship/) can help you do.
42+
43+For those interested in contributing there are some simple instructions on [GitHub](https://github.com/urbit/urbit/blob/master/CONTRIBUTING.md#contributing-to-urbit), but we also run a [grants program](https://grants.urbit.org/) where we reward contributors with Urbit ID address space. Grants aren’t solely for pre-determined projects, either. If you have something you’d like to propose, we’d love to hear from you.
44+
45+We also run a bi-monthly course called ‘Hoon School’ to teach people about the system. Hoon School is designed for anyone with the most basic technical skills — you don’t have to be an expert programmer. If you’re interested, you should [apply](/community/hoonschool). We accept everyone we can and only close the class when it gets too big.
46+
47+<img class="full w-100 mv4" src="https://media.urbit.org/site/understanding-urbit/project-history/history-4.svg"/>
48+
49+At the beginning, Urbit was just a few people with the right combination of imagination and discipline to try to rebuild computing.
50+
51+**2002**
52+
53+Urbit starts as an open-ended personal project. An “independent study PhD” to reinvent computing for a network-centric world.
54+
55+**2008**
56+
57+Nock, the foundation of Urbit, works. Coming in at 32 lines of code, that’s 1 line of code every two months.
58+
59+**2012**
60+
61+Hoon, Urbit’s programming language, compiles itself to Nock. Writing Hoon is much easier than writing Nock.
62+
63+**2013**
64+
65+Arvo, Urbit’s OS kernel, boots and the first live Urbit network is started with a command-line chat.
66+
67+**2014**
68+
69+Tlon is founded to help support Urbit development (and is < 8 people for the next four years).
70+
71+**2015**
72+
73+Urbit has its first web interface and serves its own website.
74+
75+**2016**
76+
77+The first sale of Urbit address space sells out in four hours.
78+
79+**2017**
80+
81+Our test network runs for ten months without a reboot.
82+
83+Our private sale, shared only with our mailing list, sells out in six hours — limit two per person.
84+
85+**2018**
86+
87+Tlon sells about 8% of its stake in the network to accelerate Urbit development.
88+urbit.live gets going and starts selling Urbit IDs to the public.
89+
90+**2019**
91+
92+Tlon spends the year stabilizing Arvo and building OS 1.
93+
94+<img class="ba" src="https://media.urbit.org/site/understanding-urbit/uu-history-4.jpg"/>
95+
96+Building Urbit is about building a future where technology doesn’t control us. Instead, we look forward to a future where technology is simpler, more reliable and less invasive.
97+
98+Keep in touch while we make build this vision into reality by [joining our mailing list](https://urbit.us11.list-manage.com/subscribe/post?u=972a03db9e0c6c25bb58de8c8&id=be143888d2) or following us on [Twitter](https://twitter.com/urbit) or [GitHub](https://github.com/urbit).
99+
100+If you’re somewhat technical and you’d like to help and contribute, [install Urbit](/using/install) and consider [applying for a grant](https://grants.urbit.org/s).
101+
102+If you’re interested in homesteading a community when OS 1 comes out, [apply here](/community/community-grants).
103+
104+Or if you’re curious to try Hoon School, [let us know](/community/hoonschool).
content/understanding-urbit/project-history.mddeleted−79
@@ -1,79 +0,0 @@
1−+++
2−title = "Project Status + History"
3−description = "Where we've been and were we are now"
4−weight = 7
5−[extra]
6−flatten_pagination = "true"
7−hide_next_title = "true"
8−hide_previous_title = "true"
9−image = "https://media.urbit.org/site/understanding-urbit/project-history/project-status-landscape-earth%402x.png"
10−+++
11−
12−Can you move to Urbit today and never look back? Not quite yet. Urbit is still young.
13−
14−
15−<img class="mv5 w-100" src="https://media.urbit.org/site/understanding-urbit/project-history/project-status-landscape-earth%402x.png">
16−
17−Currently, Urbit ID is live and deployed. That means you can own a piece of Urbit — if you can find one. There are thousands of people that can potentially invite you, and we give away invites from time to time. Your Urbit ID gets you a name, a sigil, and access to Urbit OS.
18−
19−<img class="mv5 w-100" src="https://media.urbit.org/site/understanding-urbit/project-history/project-status-bridge%402x.png">
20−
21−You can interact with your Urbit ID and invite friends using [Bridge](https://bridge.urbit.org), the Urbit authentication system. You can also use Bridge to boot the current alpha of Urbit OS. Soon you’ll be able to use Bridge for payments and to explore the Urbit network.
22−
23−<img class="mv5 w-100" src="https://media.urbit.org/site/understanding-urbit/project-history/project-status-landscape%402x.png">
24−
25−Urbit OS is a solid alpha. We use it every day to coordinate and chat about the future of Urbit. You’re [welcome to join](@/using/install.md). Our standards are high, so we aren’t asking everyone to use Urbit OS yet. If you’re someone who wants to customize their own software and experiment with a new system, [check it out](@/using/install.md). Otherwise, [join the mailing list](https://urbit.us11.list-manage.com/subscribe/post?u=972a03db9e0c6c25bb58de8c8&amp;id=be143888d2). We have exciting things planned for 2020.
26−
27−Urbit OS isn’t just an interface — it’s a complete system. You should also check out the [GitHub repository](https://github.com/urbit/urbit), our [open grants program](https://grants.urbit.org) and the [documentation](@/docs/_index.md). Building a system from scratch is a huge and enormously fun undertaking. There’s a lot going on, and we do all our development in public. Systems programmers, functional programming nerds, anyone who wants to tinker with their software will probably love playing with Urbit.
28−
29−<img class="mv5 w-100" src="https:///media.urbit.org/site/understanding-urbit/project-history/history-4.svg">
30−
31−At the beginning, Urbit was just a few people with the right combination of imagination and discipline to try to rebuild computing. Now it's a community of thousands of address space holders, dozens of open source developers, at least two independent companies ([Tlon](https://tlon.io) — which works mostly on kernel development and interface design, and [urbit.live](https://urbit.live) — which is building services on the platform), and who knows how many fans.
32−
33−<br /><br />
34−
35−## History
36−
37−<img class="mv5 w-100" src="https://media.urbit.org/site/understanding-urbit/project-history/project-history-05.svg">
38−
39−## Roadmap
40−
41−<img class="mv5 w-100" src="https://media.urbit.org/site/understanding-urbit/project-history/project-history-06.svg">
42−
43−## Future updates
44−
45−Urbit is young, but developing quickly. If you've just finished our Understanding Urbit series and want to stay connected with the project, we recommend starting with our mailing list.
46−
47−Enter your email below to get regular updates on the project.
48−
49−<iframe name="nothing" style="display:none;"></iframe>
50−<form
51−action="https://urbit.us11.list-manage.com/subscribe/post?u=972a03db9e0c6c25bb58de8c8&amp;amp;id=be143888d2"
52−method="post"
53−id="mc-embedded-subscribe-form"
54−name="mc-embedded-subscribe-form"
55−class="validate form"
56−target="_blank"
57−novalidate>
58−<div class="input-group" id="mc_embed_signup_scroll">
59− <div class="mc-field-group w-100 relative">
60− <input
61− class="bg-white black b--black ba pa3 w-100 mb2 br0 wk-appearance-none"
62− type="email"
63− name="EMAIL"
64− id="mce-EMAIL"
65− placeholder="your@email.com"/>
66− <button
67− id="mc-embedded-subscribe"
68− class="dib bn absolute bg-transparent"
69− style="font-family: 'Inter UI', san-serif; right: 3px; top: 15px; -webkit-appearance: none;"
70− type="submit"
71− name="subscribe"
72− onclick="_paq.push(['trackEvent', 'Mailing List', 'Subscribe'])">
73− <span class="fr pr1">-></span>
74− </button>
75− </div>
76−</div>
77−
78−You can also follow us on [Twitter](https://twitter.com/urbit) or [GitHub](https://github.com/urbit).
79−</form>
content/understanding-urbit/roadmap.mdnew file+80
@@ -0,0 +1,80 @@
1++++
2+title = "Roadmap: OS 1 -> OS N"
3+description = "The core ideas that Urbit is built around"
4+weight = 4
5+[extra]
6+flatten_pagination = "true"
7+hide_next_title = "true"
8+hide_previous_title = "true"
9++++
10+
11+Today, we call Urbit an ‘OS 0’. It’s an evolving open source project with a live network. In 2020, we’re planning to ship OS 1 — the first minimal but complete release of Urbit.
12+
13+As we discussed in the [last post](/understanding-urbit/interface), we see Urbit’s primary advantage as bringing together groups to share a set of modules for communication and collaboration. As Urbit matures, the set of available modules grows and expands, and the system both stabilizes and becomes more secure.
14+
15+Let’s walk through the sequence of milestones we have planned for 2020 and 2021.
16+
17+
18+![](https://media.urbit.org/site/understanding-urbit/project-history/project-status-landscape%402x.png)
19+
20+**OS 0 — 2019**
21+
22+Today, Urbit OS is an evolving prototype. Brave explorers, open-minded systems software nerds and those who want the future to arrive as fast as possible should [install Urbit](/using/install), [check it out](https://urbit.org/using/operations/), and potentially [enroll in Hoon School](/community/hoonschool).
23+
24+Urbit has evolved a lot during OS 0. We deployed the Urbit ID system to Ethereum and made huge strides toward the stability of Urbit OS (detailed [here](/blog/stable-arvo)). OS 0 has been all about refining our interface goals and making sure our system works as well as possible.
25+
26+Urbit is a community project, and the community hangs out on OS 0 to communicate and coordinate about developing the system. Come join us if you’d like to help, or just want to follow along as the system progresses.
27+
28+
29+
30+![](https://media.urbit.org/site/understanding-urbit/uu-roadmap-2.png)
31+
32+**OS 1 — Q1 2020**
33+
34+OS 1 is the first minimal but complete release of Urbit. We think of it as the [Nokia 3310](https://en.wikipedia.org/wiki/Nokia_3310) of cloud computers.
35+
36+OS 1 is a simple system to publish notes, chat and share links with groups of friends all in one place. OS 1 is stripped down, but open for anyone to extend and build on top of. It’s easy to onboard a group of friends into OS 1 via email and there will be hosting available to select groups.
37+
38+OS 1 is aimed first and foremost at communities looking to homestead a new platform they can truly make their own. We’ve been using Urbit ourselves over the years, and OS 1 is what we’ve been looking forward to using for our own daily communication and collaboration.
39+
40+While we’re excited about what OS 1 is, there are also plenty of gaps. For example, OS 1 doesn’t have an exceptional notification system, it still lives in a browser, and it lacks great tooling for distributing new modules. While we aren’t inventing any new cryptography, Urbit also hasn’t been audited, so we aren’t calling it secure just yet.
41+
42+If OS 0 is for explorers, OS 1 is for tinkerers. More like car camping than backpacking.
43+
44+Tlon is also planning to provide free hosting to a limited number of groups who want to homestead the system. (Although you can always host Urbit yourself, of course.) If you’re interested in trying OS 1 with your group of friends, [let us know](/community/community-grants).
45+
46+OS 2 is where Urbit gets easier for a broader audience to try out.
47+
48+
49+
50+![](https://media.urbit.org/site/understanding-urbit/uu-roadmap-3.png)
51+
52+**OS 2 — Q2 2020**
53+
54+OS 2 is an approachable, expanded and easier to use OS 1. We think of OS 2 as the [iOS 1](https://en.wikipedia.org/wiki/IPhone_OS_1) of cloud computers — no matter how silly that sounds.
55+
56+Like OS 1, OS 2 let’s a group of people chat, publish blogs and short messages, and share links. The main difference is that OS 2 is a standalone app (rather than the browser tab of OS 1) and supports Urbit-to-Urbit payments in BTC and ETH. OS 2 is the calm, private computing environment we’ve been waiting for.
57+
58+OS 2 is for those eager to leave behind MEGACORP platforms and build new, intentionally architected communities. If OS 1 is car camping, OS 2 is a geodesic dome on the playa. Not exactly a permanent home, but a good start.
59+
60+While OS 2 is a big improvement, it’s still not audited to be secure. Turning that corner happens with OS 3.
61+
62+
63+
64+![](https://media.urbit.org/site/understanding-urbit/uu-roadmap-4.png)
65+
66+**OS 3 — 2021**
67+
68+Over the course of 2020 Urbit OS will be audited to ensure it’s completely secure. Real security, along with big improvements to our hosting infrastructure, will make OS 3 the first Urbit OS for serious work and very broad consumption.
69+
70+OS 3 makes it possible to customize a permanent, secure space for your friends, company or collaborators. With OS 3, Urbit is no longer just experimental; it’s ready for real work.
71+
72+OS 3 means you can use Urbit in earnest for everyday work. Payments, contracts, managing your entire crypto portfolio, and connecting to critical IoT devices are all possible. The range of features you can create with a truly secure personal server are really exciting to imagine.
73+
74+OS 3 means you can safely commit personal data to your Urbit with absolute peace of mind. Modules for location tracking, biometric and health data can be used without worrying about leaking bits.
75+
76+OS 3 is ready for a small law firm, or an extended family, or the crypto syndicate you’ve been thinking of starting. Or, why not, go ahead and use OS 3 to launch that digital country you’ve been meaning to start.
77+
78+Where will Urbit be in 2022 or 2023? We can’t be sure exactly. We do have our eyes set on 2030 — when Urbit should be the primary platform for people to communicate and collaborate. We think our next steps are clear and we’re on the right path.
79+
80+By this point you might be wondering, who built this thing? Where did it come from? That’s next.
content/understanding-urbit/technical-overview.mddeleted−47
@@ -1,47 +0,0 @@
1−+++
2−title = "Technical Overview"
3−description = "A quick tour of the technology"
4−weight = 6
5−[extra]
6−flatten_pagination = "true"
7−hide_next_title = "true"
8−hide_previous_title = "true"
9−+++
10−
11−
12−
13−Owning a computer, especially a server, can feel like a job. Urbit, on the other hand, is engineered to be maintenance-free. We figure that if people are actually going to use a new computing platform, it can’t feel like work. At all.
14−
15−<img class="ba mv5 w-100" src="https://media.urbit.org/site/understanding-urbit/technical-overview/technical-overview-server.svg">
16−
17−So we built our whole stack, starting with the VM, to be as simple and compact as possible. Let’s take a look at what the system looks like from a technical perspective and get a feel for how it’s built.
18−
19−<img class="ba mv5 w-100" src="https://media.urbit.org/site/understanding-urbit/technical-overview/technical-overview-duo.svg">
20−
21−Under the hood, Urbit is two parts: an ID system and an OS. The ID system is live and deployed to Ethereum. The OS is a program that runs on top of any Unix machine with an internet connection.
22−
23−Urbit ID is incredibly simple. An Urbit ID is just a pair of an ID and a public key. Some IDs have the ability to issue a finite number of other IDs. Galaxies, the top-tier of Urbit IDs, have the ability to upgrade the Urbit ID contracts by a majority vote. Each Urbit ID also has a cascade of keys that can perform specific actions that make securing your Urbit ID simple and straightforward. For example, the key for booting Urbit OS is separate from the key for issuing children — keep that one in a safe.
24−
25−All of this is implemented as a [suite of Solidity contracts](https://github.com/urbit/azimuth) that are [deployed to Ethereum](https://etherscan.io/address/azimuth.eth) that we call ‘Azimuth’. We’re not wedded to using Ethereum forever — but it works well for now. Someday we’d like to host Azimuth on Urbit itself.
26−
27−As a compliment to Urbit ID, we implemented the [Urbit HD wallet](https://github.com/urbit/urbit-wallet-generator) which lets most people own their Urbit IDs using a simple passkey that’s easy to remember. This means you own your Urbit ID and can log in to Urbit OS with something like ID `~ravmel-ropdyl`, passkey `~poldec-tonteg-palfun-foslup`.
28−
29−Until Urbit OS is completely secure (in the next year or so, we hope), you can interact with Urbit ID through a standalone, browser-based interface called [Bridge](https://bridge.urbit.org). Bridge lets you securely manage your keys, transfer your Urbit ID, log in to Urbit OS, and so on.
30−
31−<img class="ba mv5 w-100" src="https://media.urbit.org/site/understanding-urbit/technical-overview/technical-overview-kernel@2x.png">
32−
33−In the simplest terms, Urbit OS is three things: a file, a key, and a program. The file is a log of everything that has ever happened to your Urbit. The key is derived from the same key you own your Urbit ID with.
34−
35−The program is mostly Arvo — our name for the Urbit OS kernel. Arvo is implemented in Hoon, a functional language that compiles down to Nock, our tiny set of opcodes.
36−
37−Arvo’s behavior is completely defined by a transition function that goes from `[event, current-state]` to `[effects, next-state]`. An event might be a keypress, an HTTP request, or a UDP message from another Arvo. An effect might be a command to the Unix terminal, an HTTP response, a UDP message to another Arvo or a move to one of Arvo’s kernel modules, or *vanes*.
38−
39−We currently have vanes for networking (`%ames`), timers (`%behn`), a filesystem (`%clay`), a terminal driver (`%dill`), an http server (`%eyre`), a functional build system (`%ford`), an application server (`%gall`) and a module for managing private keys (`%jael`).
40−
41−The operating system has a runtime called Vere that performs I/O for your OS. Think about it as the way your Urbit can interact with the outside world. It also handles your event log and runs Nock, our machine language.
42−
43−Nock is like a pico-Lisp with no symbols. It's a homoiconic purely functional machine code with 12 opcodes and one universal datatype, the noun: an acyclic binary tree that is either a number (which can also represent an arbitrarily large bytestream) or a cell, which is a pair of nouns.
44−
45−Hoon, the language in which the operating system is implemented, is a purely functional, statically typed, strictly evaluated programming language that compiles to Nock. It’s a little quirky, but at its core it’s a macro extension of Nock.
46−
47−Perhaps most interesting: our whole stack (except for Nock and Vere) is designed to be updated over the air. This is what makes it possible for Urbit to be a computer for life — it can grow with you.
content/understanding-urbit/urbit-id.md+30−37
@@ -1,7 +1,7 @@
11+++
22title = "Urbit ID"
33description = "An overview of the Urbit ID system"
4−weight = 4
4+weight = 2
55[extra]
66flatten_pagination = "true"
77hide_next_title = "true"
@@ -9,67 +9,60 @@ hide_previous_title = "true"
99image = "https://media.urbit.org/site/understanding-urbit/urbit-id/urbit-id-cards%402x.png"
1010+++
1111
12−Every time you post a comment, like something, send a message, or use any app or service, you need an account. (And, behind the scenes, a network address.) Neither of these things belongs to you. The way things are going, they never will. No matter what you’re up to with your phone or laptop, you’re dependent on MEGACORP.
12+Assuming Urbit OS is simple enough for an ordinary user to own and operate, how do they log in? How do people identify one another on this new network? When people want to get data, files and messages to one another, how do they do it? And how do we prevent spam?
1313
14−<img class="ba mv5 w-100" src="https://media.urbit.org/site/understanding-urbit/urbit-id/urbit-id-megacorp.svg">
14+Urbit ID is the answer to all these questions. Urbit ID is a decentralized addressing and public key infrastructure designed for Urbit OS.
1515
16−We don’t like being owned by someone else. We think your identity and wallet should feel like a unique and precious object that you can always carry with you. So we built Urbit ID.
16+Let’s talk first about what an Urbit ID is and what it does. Then we’ll cover our design goals and how the system works overall.
1717
18−<img class="ba mv5 w-100" src="https://media.urbit.org/site/understanding-urbit/urbit-id/urbit-id-cards%402x.png">
18+<img class="ba" src="https://media.urbit.org/site/understanding-urbit/urbit-id/urbit-id-cards%402x.png">
1919
20−Urbit ID is meant to feel like a civilizational key. If your Urbit ID were a piece of hardware, you could tap it to unlock a door, swipe it to buy a coffee, and plug it into any computer to log in. It’s a unique, beautiful object that’s both an address and a wallet. It’s a key to a secret club and the ticket to your digital life.
20+Your Urbit ID is a short, four-syllable name like `~ravmel-ropdyl` that you own with an eight-syllable master passkey like `~palfun-foslup-fallyn-balfus`. This name and key lets you log into Urbit OS, and it’s used to encrypt packets you send over the Urbit network. Soon it will also be a master key that allows holding and sending of Bitcoin and other cryptocurrencies. Your Urbit ID and passkey belong to you like any other cryptographic assets. No one can take them away from you (just make sure to store the key safely).
2121
22−Your Urbit ID isn’t a physical object (yet). Instead, it’s even simpler. Your Urbit ID is a name and passkey that’s easy to memorize.
22+The Urbit ID registry is live and deployed to the Ethereum blockchain. Urbit ID isn’t specifically wedded to Ethereum – someday we’d like it to be hosted by Urbit OS itself. Also, Urbit ID is the only component of the stack using Ethereum – your Urbit OS node is hosted wherever you choose. The primary function of the Urbit ID registry is to keep track of who owns what, to specify which keys are associated with which names, and to enforce the rules of address distribution. We’ll get into the details a bit more below.
2323
24−If you wake up in the desert, unsure how you got there, you’ll be fine so long as you remember your Urbit ID and passkey. With it, you still own your digital identity and your digital assets. If you remember your friend’s Urbit ID you can always connect and send them money or messages.
24+First, let’s talk about Urbit ID’s implementation and design goals, then about where we envision it going in the future.
2525
26−Urbit ID is a simple, decentralized system for people to own their digital addresses and crypto wallets. Urbit ID is a system owned by its users, designed to last far into the future, that’s live and usable today.
26+If you’re curious to see exactly how this system works, the code is of course [open source](https://github.com/urbit/urbit). Including the source for our [phonemic naming system](https://github.com/urbit/urbit-ob/blob/master/src/internal/co.js) and the [visual representations](https://github.com/urbit/sigil-js). There’s even a [Figma plugin](https://github.com/urbit/sigil-figma-plugin) for using them. There’s also an interface for interacting with Urbit ID whose source is [open too](https://github.com/urbit/bridge).
2727
28−Urbit ID is a completely separate system from Urbit OS. It’s finished and deployed to Ethereum already. We designed Urbit ID to log in to Urbit OS, but it can be used for anything.
28+Since the Urbit ID registry is live and deployed you can even [look at the chain](https://github.com/urbit/azimuth#live-contracts).
2929
30−For those curious to understand Urbit ID a bit better, we’ll cover the basics of how Urbit ID works.
30+<img class="ba" src="https://media.urbit.org/site/understanding-urbit/urbit-id/urbit-id-paperwallet%402x.png">
3131
32−<img class="ba mv5 w-100" src="https://media.urbit.org/site/understanding-urbit/urbit-id/urbit-id-paperwallet%402x.png">
32+Each Urbit ID is really just a number. From that number we generate a pronounceable name and a visually identifiable sigil. `~dalwel-fadrun` is `3,509,632,436`, for example.
3333
34+Urbit IDs are distributed by a sponsorship tree. At the top of the tree are 2<sup>8</sup> (256) galaxies. Each galaxy issues 2<sup>8</sup> stars, making a total of 2<sup>16</sup> (65K). Stars then each can issue 2<sup>16</sup> planets, making for 2<sup>32</sup> (~4B). As you might expect, each planet issues 2<sup>32</sup> moons.
3435
35−Your Urbit ID is a short, memorable address that anyone can use to connect with you that *doesn’t* depend on any company. It’s an address you own completely and can keep forever.
36+You can also call stars ‘infrastructure nodes’ and galaxies ‘governance nodes’, since those are more descriptive names for their roles. Stars help route packets, kind of like an ISP. And galaxies are a bit like DNS root servers or ICANN members. The difference, of course, is that Urbit IDs are owned cryptographically by many different people and accrue reputation independently.
3637
37−For most people, an Urbit ID looks something like `~tinbel-picpel`. You own it with a simple, memorable key twice its length, like `~winter-paches-palfun-foslup`. Urbit IDs are designed not to have any personally identifying information attached to them at all, sort of like a phone number. Each name and password is automatically generated — so we don’t accidentally leak data when we meet a stranger in the digital world.
38+And that's it. It's a simple system. What's important is why it is the way it is. Let's take a look at that.
3839
39−Your Urbit ID and passkey are all you need to log into Urbit OS and send and receive crypto payments. Together, they’re a simple keypair that are easily memorizable. We think it’s the perfect form factor for ordinary people to take control of their digital lives.
40+<img class="full ba w-100 mv4" src="https://media.urbit.org/site/understanding-urbit/urbit-id/urbit-id-address-space-1.svg"/>
4041
41−<img class="b—black ba mv5 w-100" src="https://media.urbit.org/site/understanding-urbit/urbit-id/urbit-id-address-space-2.svg">
42−
43−We want everyone to own their own identity and wallet. One way to do this would be to build a MEGACORP or a Centralized Naming Authority of Urbit. But we prefer decentralized, collectively owned systems. So that’s what we built. Let’s look briefly at the basic mechanics of Urbit ID.
44−
45−Each Urbit ID is just a number. From that number we generate a pronounceable name and visually identifiable sigil. `~dalwel-fadrun` is `3,509,632,436`, for example.
46−
47−Urbit IDs are distributed by a sponsorship tree. At the top of the tree are `2^8` (`256`) galaxies. Each galaxy issues `2^8` stars, making a total of `2^16` (`65K`). Stars then each can issue `2^16` planets, making for `2^32` (`~4B`). As you might expect, each planet issues `2^32` moons.
48−
49−Every Urbit ID needs a sponsor. Stars and planets can always move to a new one. The galaxies act as a senate to upgrade the system by majority vote.
42+At a high level, there are three important things to understand about the overall Urbit ID system design.
5043
51−And that's it. It's a simple system. What's important is *why* it is the way it is. Let's take a look at that.
44+First, scarcity: there are only 2<sup>32</sup> (~4B) Urbit IDs, so they cost something. Since they cost something, people are less likely to use them to spam or abuse the network. When you meet a stranger with an Urbit ID, you know they have some skin in the game (even without leaking personal data in either direction). That said, each Urbit ID is purely pseudonymous, so `~dalwel-fadrun` for example, is proof of some stake in the network, but not much more.
5245
53−<img class="b—black ba mv5 w-100" src="https://media.urbit.org/site/understanding-urbit/urbit-id/urbit-id-address-space-1.svg">
46+Second, decentralization: Urbit IDs are distributed by a sponsorship tree. Each sponsor issues a fixed number of addresses. Since there are lots of sponsors, there are lots of ways to get an Urbit ID — not just one central authority. Once you get one, it’s yours forever.
5447
55−At a high level, there are three important things to understand about the overall Urbit ID system design.
48+One point that’s useful to understand about sponsors is that while Urbit IDs always need a sponsor, or parent node on the network (primarily for peer discovery), it’s always possible to change sponsors and sponsors can always reject children. This means bad actors can be banned and abusive sponsors can be ignored. We think this strikes a nice balance between accountability and freedom.
5649
57−First, there are only so many Urbit IDs, so they cost something. Since they cost something, people are less likely to use them to spam or abuse the network. And, when you meet a stranger with an Urbit ID, you know they have some skin in the game without them leaking any personal data in either direction. Each Urbit ID is purely pseudonymous. `~dalwel-fadrun`, for example, is only proof of some stake in the network.
50+Third, governance: galaxies (the top of the sponsorship tree) form a senate that can upgrade the logic of the Urbit ID system by majority vote. We think Urbit ID will last for quite a long time, but if it ever needs to be updated, the galaxies can vote to approve, reject, or propose changes to the contracts. Code may be law, but ultimately we acknowledge that human judgment can’t be factored out.
5851
59−Second, Urbit IDs are distributed by a sponsorship tree. Each sponsor issues a fixed number of addresses. Since there are lots of sponsors, there are lots of ways to get an Urbit ID — not just one central authority.
52+The Urbit ID sponsorship tree is not intended to be a social system in any way. Interactions between people and communities on the Urbit network are peer-to-peer, entirely organic and completely uncontrolled by the address hierarchy. Urbit ID is simply an authentication substrate upon which reputation and communication systems can be built. (We’ve even considered renaming stars and galaxies ‘infrastructure’ and ‘governance’ nodes, respectively).
6053
61−Urbit IDs need a sponsor even after they’re issued, but you can always change sponsors and sponsors can always reject children. This means bad actors can be banned and abusive sponsors can be ignored. We think this strikes a nice balance between accountability and freedom.
54+Your relationship with your sponsor should be sort of like your ISP or a utility provider: a passive, non-invasive relationship. If it isn’t to your liking, moving to a new sponsor is very easy.
6255
63−Finally, galaxies (the top of the sponsorship tree) form a senate that can upgrade the logic of the Urbit ID system by majority vote. We think Urbit ID should last for quite a long time, but if it ever needs to be changed, the galaxies can facilitate upgrades. Code may be law, but ultimately we acknowledge that human judgment can’t be factored out.
56+<img class="ba" src="https://media.urbit.org/site/understanding-urbit/urbit-id/urbit-id-sigils%402x.png">
6457
65−(For a bit more on how all this works, see the [FAQ](@/faq.md).)
58+Urbit IDs are property, and we think of the entire registry of Urbit IDs as a vast territory of digital land.
6659
67−Urbit ID isn’t just a design. It’s [live and deployed](https://azimuth.network) to the Ethereum blockchain.
60+The scarcity of Urbit ID address space gives it value and that in turn helps bootstrap decentralization even while the project is young. Broad distribution is important – If Urbit is going to last a long time and succeed as neutral infrastructure, it has to be owned and controlled by a wide variety of people.
6861
69−<img class="b—black ba mv5 w-100" src="https://media.urbit.org/site/understanding-urbit/urbit-id/urbit-id-sigils%402x.png">
62+When we launched the Urbit ID system, in January of 2019, there were a couple thousand different star and galaxy holders acting as stewards of this digital land. Since then, that number has been steadily on the rise.
7063
71−Urbit IDs are digital property, and we think of the entire address space of Urbit IDs as a vast territory of digital land.
64+<img class="ba" src="https://media.urbit.org/site/understanding-urbit/project-history/uu-id-5.jpg">
7265
73−The scarcity tree of Urbit ID address space drives decentralization even while the project is young, which is great. If Urbit ID is going to last a long time and succeed as neutral infrastructure, it has to be owned and controlled by a wide variety of people.
66+Ultimately, we want your Urbit ID to feel like a civilizational key. If your Urbit ID were a piece of hardware, you could tap it to unlock a door, swipe it to buy a coffee, and plug it into any computer to log in. Your Urbit ID should be a unique, beautiful object that’s both an address and a wallet. It’s a key to a secret club and the ticket to your digital life.
7467
75−When we launched the Urbit ID system, in January of 2019, there were a few thousand different star and galaxy holders – stewards of this digital land. Since then, that number is on the rise.
68+Moving on, let’s talk about what we want this whole stack to feel like as a user experience.
content/understanding-urbit/urbit-os.mdnew file+58
@@ -0,0 +1,58 @@
1++++
2+title = "Urbit OS"
3+description = "What Urbit should feel like to an everyday user"
4+weight = 1
5+[extra]
6+flatten_pagination = "true"
7+hide_next_title = "true"
8+hide_previous_title = "true"
9+image = "https://storage.googleapis.com/media.urbit.org/site/understanding-urbit/intro/intro-5.jpg"
10++++
11+
12+For the most part, we use our laptops simply as access points to MEGACORP services. Our phones are the same. These services are amazing and convenient. But for that convenience we’ve traded away control, ownership and privacy. The way we live our digital lives is completely out of our hands.
13+
14+<img class="ba" src="https://storage.googleapis.com/media.urbit.org/site/understanding-urbit/intro/intro-5.jpg">
15+
16+Today’s MEGACORP monopolies retain their control because of one central technical advantage: they make the server side usable.
17+
18+Urbit OS is built to break these monopolies at this central point of control. Urbit OS makes the server side usable for individuals without the need for MEGACORP to run their software.
19+
20+We’ve already been through this before. In 1974 a computer was a mainframe the size of a room and was shared by hundreds of people. By 1984 a computer was the size of a desk and everyone had their own PC. The PC was more flexible and more fun, so it won by a wide margin. Then, with the rise of the internet, the PC’s flexibility slowly became irrelevant.
21+
22+Today, we’re more or less back to the timesharing model of the 1970s. Urbit OS is the PC to MEGACORP’s mainframe. It’s more flexible, more fun, and most of all, poised to capture the everyday creativity of the individual.
23+
24+Let’s talk about how we think we’re going to pull this off from a technical standpoint, and our vision for using Urbit.
25+
26+If you’d like to skip ahead to what Urbit will be like to use [go ahead](/understanding-urbit/interface). Or if you’re someone who just wants to head to the source, [it’s here](https://github.com/urbit/urbit#urbit). In that case you may also want to [read the docs](https://urbit.org/docs/) to get up and running.
27+
28+<img class="ba" src="https://media.urbit.org/site/understanding-urbit/technical-overview/technical-overview-kernel@2x.png">
29+
30+Urbit OS is a completely new, carefully architected software stack: a VM, programming language, and kernel designed to run software for an individual. Urbit OS is a program that runs on almost any cloud server, most laptops and many phones: anything with Unix and an internet connection.
31+
32+The main thing to understand about our ‘overlay OS’, as we call it, is that the foundation is a single, simple function. This function is the Urbit OS virtual machine. We call it ‘Nock’. The entire Urbit OS system compiles down to Nock, and Nock is just 33 lines of code.
33+
34+Nock is similar in spirit to WASM or the JVM: it’s a uniform machine code for every Urbit ship. A frozen foundation makes for some nice features:
35+
36+The state of your Urbit OS is a pure function of its event history. It’s auditable, inspectable, repeatable. You can actually trust it.
37+Writing decentralized apps becomes vasty simpler than in the old world, since every node computes exactly the same way.
38+The entire Urbit OS stack, from programming language to applications, is upgradeable over the network. For ordinary users, this makes for almost no system administration.
39+
40+Since Nock is a protocol for computing itself, any two nodes on the urbit network can easily share data, communicate and connect their software. 20th century systems could never do this without a MEGACORP acting as the intermediary.
41+
42+<img class="full ba w-100 mv4" src="https://media.urbit.org/site/understanding-urbit/network-os/urbit-os-diagram-apart.svg"/>
43+
44+On top of this tiny VM we built a self-hosting, purely functional programming language, a kernel written in that language and a set of kernel modules that serve all the needs of personal computing. Specifically: a filesystem, build system, application sandbox, secret storage, web server, terminal driver and a networking protocol.
45+
46+This sounds like a lot — but the whole stack is incredibly compact. The whole system clocks in at around 50K lines of code. We’ve seen individual developers understand the entire thing. Who is the last person you met that actually understands their entire computer? Urbit OS is like the 1968 Porsche 911 of operating systems: extremely simple, elegant, and built for the individual.
47+
48+<img class="ba" src="https://media.urbit.org/site/understanding-urbit/project-history/uu-os-4.jpg">
49+
50+But why did we build all this technology?
51+
52+First and foremost, to deliver a better user experience. Urbit OS alone is just a new layer for personal computing in the cloud. But with this new layer we open up the possibility of building a completely unified interface for people to compute in the cloud. (If you’d like to skip to how we envision that interface [go for it](/understanding-urbit/interface).)
53+
54+From a broader perspective, it’s clear that connected computing is important and that it’s here to stay. We just want it to be as calm, simple and reliable as possible, and we don’t think can happen using existing technology.
55+
56+All of Urbit is built to function as a single stack, and we think that building a useful product is the best way to mature the system as a whole. That said, each component of this system can be used on its own. Don’t like our client? That’s okay, you can build your own. Don’t want to use Urbit OS? No problem — you can use Urbit ID as an authentication system for some other OS, or for anything, really.
57+
58+Speaking of Urbit ID, let’s talk about what that actually is.
content/updates/2019-11-06-update.md+11−11
@@ -2,7 +2,7 @@
22title = "~2019.11.06 Update"
33date = 2019-11-06
44description = "Weekly Web Update"
5−slug = "/updates/2019-11-06"
5+slug = "2019-11-06"
66aliases = ["/posts/updates/2019-11-06-update", "/posts/2019-11-06-update/"]
77[extra]
88author = ""
@@ -12,29 +12,29 @@ image = "https://media.urbit.org/site/posts/updates/~2019.11.06-update.jpg"
1212
1313![](https://media.urbit.org/site/posts/updates/~2019.11.06-update.jpg)
1414
15−Hello from San Francisco!
15+Hello from San Francisco!
1616
17−We’re thinking of everyone in the North Bay and elsewhere who were affected by the recent fires. While we’ve had a few days of poor air quality in SF, we’re grateful that it hasn’t been as bad as last year.
17+We’re thinking of everyone in the North Bay and elsewhere who were affected by the recent fires. While we’ve had a few days of poor air quality in SF, we’re grateful that it hasn’t been as bad as last year.
1818
1919Here are some updates from the Tlon team:
2020
21211 -
2222Tlon has been on tour! We just got back from Berlin where we gave a talk at the Lightning Conference. [Check it out](https://youtu.be/vVIt06w3IbM?t=2030). While we were there, we [talked](https://www.youtube.com/watch?v=775vmOKxwSY) to the World Crypto Network.
2323
24−2 -
24+2 -
2525If you’re wondering what all this Bitcoin stuff is about, we summed it up [here](https://urbit.org/blog/urbit-and-bitcoin/).
2626
27−3 -
27+3 -
2828We’re offering a free, introductory-level online course on Hoon, the programming language that’s designed for use with Urbit. Hoon 101 begins on November 11th and runs for six weeks. Sign up [here](https://urbit.org/hoonschool/).
2929
30304 -
31−We’ve got a new version of Ames (the Urbit OS / Arvo networking protocol) compiling and up to date with master. `~pilfer-pandex` also wrote some compiler documentation that is getting rave reviews around the office. `~wicdev-wisryt` was so inspired that he added tab completion to the Dojo and built [a language server](https://github.com/urbit/urbit/pull/1910).
31+We’ve got a new version of Ames (the Urbit OS / Arvo networking protocol) compiling and up to date with master. `~pilfer-pandex` also wrote some compiler documentation that is getting rave reviews around the office. `~wicdev-wisryt` was so inspired that he added tab completion to the Dojo and built [a language server](https://github.com/urbit/urbit/pull/1910).
3232
33−5 -
33+5 -
3434Kenny, a long time community member, is hosting the first-ever Urbit meetup in Seattle on November 12th. Details [here](http://meetu.ps/c/4tZGf/c0Pdg/a).
35−
36−6 -
35+
36+6 -
3737The next San Francisco meetup is on November 15th. [RSVP here](https://www.meetup.com/urbit-sf/events/266146513/).
38−
39−
38+
39+
4040Until next time.
content/updates/2019-12-06-update.md+8−8
@@ -2,7 +2,7 @@
22title = "~2019.12.6 Weekly Web Update"
33date = 2019-12-06
44description = "Weekly Web Update"
5−slug = "/updates/2019-12-06"
5+slug = "2019-12-06"
66[extra]
77author = ""
88ship = ""
@@ -18,9 +18,9 @@ We recently released urbit v0.10.0. This continuity-breaching release contains b
1818
1919A few release highlights:
2020
21−* Our networking vane, Ames, has been completely rewritten. Its protocol has been simplified, and several new features have been added to it. We expect Ames to be much more reliable and easy to upgrade.
21+* Our networking vane, Ames, has been completely rewritten. Its protocol has been simplified, and several new features have been added to it. We expect Ames to be much more reliable and easy to upgrade.
2222
23−* Perhaps most importantly, Ames now supports arbitrary-length negative acks, which was one of the primary networking bugs on our old network.
23+* Perhaps most importantly, Ames now supports arbitrary-length negative acks, which was one of the primary networking bugs on our old network.
2424
2525* Gall, our application sandbox, has also been significantly changed. This has also been a long-running project at Tlon that we’re really excited to get out on the live network. Gall itself is about a thousand lines shorter.
2626
@@ -30,14 +30,14 @@ A few release highlights:
3030
3131Check out the full release notes [here](https://github.com/urbit/urbit/releases/tag/v0.10.0).
3232
33−2 -
33+2 -
3434This year we set out to get Arvo to a point that we can credibly call ‘stable.' ~poldec-tonteg wrote about the details of how we accomplished stability [here](https://urbit.org/blog/stable-arvo/).
3535
36−3 -
36+3 -
3737The final San Francisco meetup of the year is on December 13th. We hope to see you – [RSVP here](https://www.meetup.com/urbit-sf/events/266904108/?rv=ea1_v2&_xtd=gatlbWFpbF9jbGlja9oAJDA0YTUxZjZlLWU1ZGQtNGJkYS1hN2JlLWQwZTc0MDA0ZTAwZA).
3838
39−4 -
39+4 -
4040The Seattle Urbit group is hosting a meetup on December 18th. [RSVP](https://www.meetup.com/Urbit-Seattle/events/266619060/) for tech and holiday cheer.
41−
42−
41+
42+
4343Talk to you soon!
content/updates/2020-02-06-update.mdnew file+41
@@ -0,0 +1,41 @@
1++++
2+title = "~2020.2.6 Update"
3+date = 2020-02-06
4+description = "A brief update from the Tlon team for ~2020.2.6."
5+slug = "2020-02-06"
6+[extra]
7+author = "Corrina"
8+ship = "~roslet-tanner"
9+image = "https://media.urbit.org/site/posts/updates/~2020.02.06-update.jpg"
10++++
11+
12+![pajaro dunes](https://media.urbit.org/site/posts/updates/~2020.02.06-update.jpg)
13+
14+It’s been a busy 2020 already, and we’re excited about everything that’s going live this year. Here’s the latest from the Tlon team:
15+
16+1. Last month’s updates to Arvo and Bridge included:
17+Fixes related to the network stability vote.
18+[Updates](https://github.com/urbit/urbit/pull/1996) to both Gall and Ames (our application sandbox and networking module, respectively).
19+[Support in Bridge](https://github.com/urbit/bridge/pull/335) for withdrawing stars from the linear release contracts.
20+
21+2. Gavin (`~ridlur-figbud`) wrote about how we created sigils, the visual representation of Urbit IDs. Read the post [here](https://urbit.org/blog/creating-sigils/).
22+
23+3. We’re pleased to announce the latest round of our semiannual gifts to Urbit contributors. It’s our way of rewarding the hard work of contributors to the project over the last six months. To see all the contributions we’ve recognized, take a look at the [History](https://grants.urbit.org/history) section on the Grants website.
24+ - `~bannum-magtus` has been tireless in their efforts as a community Guide in the #ship-starting-support channel on our [Discord server](https://discord.gg/C9ENTt3), and as an Urbit evangelizer.
25+ - `~nolmeg-hobdyn` could also be found nearly every day volunteering as a Guide in #ship-starting-support.
26+ - `~minder-folden` was a deep font of Urbit-related content, outreach, and support.
27+ - `~risruc-habteb` provided invaluable, consistent support in urbit-help.
28+ - `~rabsef-bicrym` for their efforts to teach Hoon to the community.
29+ - [`~dinleb-rambep`](https://github.com/pkova) brought a steady stream of useful contributions to the [urbit repository](https://github.com/urbit/urbit/pulls?utf8=%E2%9C%93&q=author%3Apkova).
30+
31+4. Looking for a more formal way to contribute and get rewarded? Look for a [Bounty](https://grants.urbit.org/bounties) to claim, or pitch a [Proposal](https://grants.urbit.org/proposals) of your own. We’re always on the lookout for community members who distinguish themselves through their contributions.
32+
33+5. Community member Reid is hosting a Dallas-Fort Worth meetup on February 12. [RSVP](https://www.meetup.com/Urbit-DFW/events/268194997/?rv=ea1_v2&_xtd=gatlbWFpbF9jbGlja9oAJGUwMGVjNGVmLTM3YTMtNDI1Yy05MDY1LTMyZGNiZjIxNDc2MA) to join.
34+
35+6. `~rabsef-bicrym` is coordinating a Denver meetup on February 13 during [ETHDenver](https://www.ethdenver.com/). Come say hi to other community members and folks from Tlon. For more details and to RSVP contact `~rabsef-bicrym` at [denver.urbit.meetup@protonmail.com](mailto:denver.urbit.meetup@protonmail.com).
36+
37+7. The next SF meetup will be on February 28 at our offices. Join us for a drink and a chat about all things Urbit. [RSVP](https://www.meetup.com/urbit-sf/events/268519069/?rv=co1&_xtd=gatlbWFpbF9jbGlja9oAJDYzNTAyYWNhLTBlYWQtNDAwNC1iODNlLTljMDk0NzQyNTE3NQ) and bring a friend.
38+
39+We’ve also scheduled a meetup in SF for [March 27](https://www.meetup.com/urbit-sf/events/268519156/). We hope to see you at one of these events!
40+
41+Until next time.
content/using/develop.md+2−2
@@ -8,11 +8,11 @@ aliases = ["/docs/using/creating-a-development-ship/", "/docs/getting-started/co
88
99There are roughly two kinds of development on Urbit: core development and application development. Urbit applications are still young, but can be fun to experiment with. The kernel is much more stable, but generally more challenging from an engineering standpoint.
1010
11−This guide will start by getting you set up to run an Urbit ship, and then tell you everything you need to now do to either.
11+This guide will start by getting you set up to run an Urbit ship, and then tell you everything you need to know to do either.
1212
1313### Setting up your environment
1414
15−We assume you’ve gotten a basic introduction to Urbit. If you haven’t, read the [Understanding Urbit](@/understanding-urbit/_index.md) series, or just jump ahead to the [Technical Overview](@/understanding-urbit/technical-overview.md).
15+We assume you’ve gotten a basic introduction to Urbit. If you haven’t, read the [Understanding Urbit](@/understanding-urbit/_index.md) series.
1616
1717Once you’re ready, you can get started on the network right away and take some first steps, without acquiring an identity, by [creating a comet](@/using/operations/creating-a-comet.md).
1818
content/using/install.md+16−7
@@ -17,7 +17,7 @@ For an introduction to Urbit IDs and the address space more generally, see [Urbi
1717While Tlon does not currently sell or distribute Urbit IDs, there are still a few ways to get your own Urbit ID:
1818
1919- Getting an invitation from a friend
20−- Purchasing an Urbit ID from a third party, such as [urbit.live](https://urbit.live), [OpenSea](https://opensea.io), or [Urbit Marketplace](https://urbitmarketplace.com/).
20+- Purchasing an Urbit ID from a third party, such as [urbit.live](https://urbit.live), [OpenSea](https://opensea.io), [planet.market](https://planet.market/), or [Urbit Marketplace](https://urbitmarketplace.com/).
2121
2222Tlon occasionally selects candidates to distribute invitations, and users operating galaxies and stars can spawn and distribute a finite number of stars and planets, respectively.
2323
@@ -45,8 +45,9 @@ Urbit: a personal server operating function
4545We provide static binaries for macOS. You can grab the latest stable release as follows:
4646
4747```sh
48−curl -O https://bootstrap.urbit.org/urbit-darwin-v0.10.1.tgz
49−tar xzf urbit-darwin-v0.10.1.tgz
48+curl -O https://bootstrap.urbit.org/urbit-v0.10.4-darwin.tgz
49+tar xzf urbit-v0.10.4-darwin.tgz
50+cd urbit-v0.10.4-darwin
5051./urbit
5152```
5253
@@ -55,8 +56,9 @@ tar xzf urbit-darwin-v0.10.1.tgz
5556We also provide static binaries for 64-bit Linux distributions (Ubuntu, Debian, Fedora, Arch, etc.). You can get the latest stable release similarly:
5657
5758```sh
58−curl -O https://bootstrap.urbit.org/urbit-linux64-v0.10.1.tgz
59−tar xzf urbit-linux64-v0.10.1.tgz
59+curl -O https://bootstrap.urbit.org/urbit-v0.10.4-linux64.tgz
60+tar xzf urbit-v0.10.4-linux64.tgz
61+cd urbit-v0.10.4-linux64
6062./urbit
6163```
6264
@@ -66,6 +68,7 @@ To access your Urbit via HTTP on port 80 on Ubuntu, you may need to run the foll
6668sudo apt-get install libcap2-bin
6769sudo setcap 'cap_net_bind_service=+ep' /path/to/urbit
6870```
71+(Where `urbit` is the urbit executable downloaded with `curl` prior)
6972
7073### Compile from source
7174
@@ -131,7 +134,14 @@ When you press Enter, you should see this:
1311344
132135```
133136
134−Good, your Dojo is working correctly.
137+Good, your Dojo is working correctly. Now let's run our first useful command in the Dojo. The first thing you generally want to do with a new ship is to **mount** it. A ship being mounted means that it has a presence on your Unix filesystem, so the files can be copied manipulated between Unix and your ship. To mount you ship, type `|mount %` at the Dojo prompt.
138+
139+```
140+|mount %
141+>=
142+```
143+
144+The `>=` output means that a command was successful. Now you can see your ship's files in its Unix directory.
135145
136146### Using Landscape
137147
@@ -141,4 +151,3 @@ Landscape is the Urbit web interface, and it's the best way to interact with you
1411512. If the port given is 80, simply type `localhost` into your browser's address bar. If the given port is a different number, such as `8080`, you would type `localhost:8080`. Alternatively, you access landscape by navigating to `ship.arvo.network` into your URL bar, where `sampel-palnet` is the name of your ship, without the `~`. You will need to [set up DNS proxying](@/using/operations/using-your-ship.md#dns-proxying) to use this option.
1421523. Type `+code` into your ship's Dojo. Copy-paste the returned code into the field asking for it in the browser page.
1431534. You're in! Now you can explore apps such as Chat for messages, Publish for blogging, and Weather.
144−
content/using/operations/using-bridge.md+6−4
@@ -10,13 +10,13 @@ aliases = ["/docs/getting-started/using-bridge/"]
1010
1111This guide assumes that you have an Urbit ID, or that you have found someone to send an Urbit ID to your Ethereum address and are looking to claim it.
1212
13−### Online Bridge
13+### Hosted Bridge
1414
1515To connect to Bridge, go to [https://bridge.urbit.org](https://bridge.urbit.org) into your browser, and enter your identity's credentials in the appropriate fields. If you were invited to claim an Urbit ID, it's very likely that you received an email that would direct you to Bridge, and you can simply follow the hyperlink in that email.
1616
1717Once you arrive, proceed through the steps presented. You'll eventually arrive at a page with a few choices: `Invite`, `Admin`, and `Boot Arvo`. `Admin` is the only option that you're interested in right now; click on it. On the `Admin` page, click the `Download Arvo Keyfile` button. Once you have downloaded the keyfile, you can exit Bridge and proceed to [install the Urbit binary](@/using/install.md).
1818
19−### Offline Bridge
19+### Local Bridge
2020
2121Alternatively, Bridge can be run locally. It's more complicated, but we recommend this option for managing sufficiently valuable assets, such as several stars or more. To install local Bridge, navigate to the [release page on GitHub](https://github.com/urbit/bridge/releases/). Download the `.zip` file of the latest version. After you download it, follow the instructions below.
2222
@@ -29,10 +29,12 @@ To use Bridge:
2929
3030You can then use the Bridge app by navigating to `http://localhost:5000` in your internet browser.
3131
32−Note: Bridge allows you to both make reads and writes to the Ethereum blockchain. Writing to the blockchain, such as changing your networking keys, will incur a transaction cost that will require you to have some ETH in your address.
32+### Log in
3333
3434Once the program is running in your browser, go through the steps presented according to the type of wallet you have. You’ll be presented with a few login options. A notable option is Urbit Master Ticket. This is for those who used our Wallet Generator software. If you bought points from an Urbit sale and then used the Wallet Generator, your networking keys will be set for you. All other login options will require you to set your own networking keys.
3535
36+Note: Bridge allows you to both make reads and writes to the Ethereum blockchain. Writing to the blockchain, such as changing your networking keys, will incur a transaction cost that will require you to have some ETH in the address you log in with.
37+
3638### Accept your transfer
3739
3840If you were given points by Tlon you likely already fully own them. But if someone else sent you a point, then you will first need to use Bridge to accept that transfer.
@@ -62,4 +64,4 @@ It should be noted that setting your network keys is an event on the Ethereum ne
6264From the detail page associated with your point, click the `Generate Arvo Keyfile` link and you'll be taken to a page with a field titled `Network seed`. This field should already be filled in, and should match the hexadecimal string that you entered in the previous step. If it's not filled in or does not match, fill it in with the correct string.
6365Click `Generate ->`, which will download a keyfile onto your machine.
6466
65−With that keyfile in hand, you can now exit Bridge and continue to the guide to [install the Urbit binary](@/using/install.md).
67+With that keyfile in hand, you can now exit Bridge and continue to the guide to [install the Urbit binary](@/using/install.md).
content/using/operations/using-your-ship.md+37
@@ -174,6 +174,31 @@ $ ./urbit -w faswep-navred-sampel-palnet -k <keyfile> -c mymoon
174174
175175Moons are automatically synced to their parent `%kids` desk, and can control applications on their parent planet using `|link`.
176176
177+### Escaping A Sponsor
178+
179+To use the network as a planet or star, you must be sponsored by an active star or galaxy, respectively. If your sponsor isn't suiting your needs, you can escape to a different one. The [Bridge](https://bridge.urbit.org/) software doesn't yet support escaping. For the time being, however, you can follow this guide.
180+
181+#### Prerequisites
182+
183+- A little bit of ETH in your management proxy address to pay for the transaction.
184+- The identity number of the sponsor you want to escape from.
185+- The identity number of the sponsor you want to escape to.
186+
187+You can find an identity's number by running ``` `@`~marzod ``` in any Dojo, where `~marzod` is the name of the relevant identity.
188+
189+#### Instructions
190+
191+0. If you have your management proxy in Metamask, you can use Etherscan [here](https://etherscan.io/address/ecliptic.eth#writeContract). Skip steps 1-4.
192+1. Go to either myetherwallet.com or mycrypto.com. Since this is a low-risk operation, and you're signing with a low-value key, it's fine to use their online versions. Sign in with your management mnemonic. (They may still force you to download their tool to log in like this.)
193+2. Navigate to the "interact with contract" page of the tool you're using.
194+3. Specify a contract address of `0x6ac07B7C4601B5CE11de8Dfe6335B871C7C4dd4d`.
195+4. Copy the "contract ABI" from [here](https://etherscan.io/address/ecliptic.eth#code) and paste it into the "ABI/JSON interface" field.
196+5. Select the `escape()` function, passing in two arguments: your identity number, and the number of your desired sponsor.
197+6. Sign and submit the transaction.
198+7. Get in touch with your prospective sponsor, since they won't be notified otherwise. You can do this by contacting them on the network via chat, or joining `~dopzod/urbit-help` and asking around.
199+8. Wait for your request to be accepted by the prospective sponsor.
200+9. If your request is not accepted by your prospective sponsor, a last resort, you can make a request to escape to `~marzod`, which is operated by Tlon, the company leading the development of Urbit.
201+
177202### Continuity breaches
178203
179204While the Urbit network is in this alpha state, we sometimes have to reboot the whole network. This happens either when major changes need to be shipped or we hit a bug that can't be fixed over the air.
@@ -182,6 +207,12 @@ Because Urbit networking is stateful we call this a _continuity breach_. Everyth
182207
183208When this happens, back up any files you'd like to save, shut down your urbit, and recreate it (as if you were starting for the first time).
184209
210+### Life and rift number
211+
212+You can check your ship's _life_ and _rift_ number by running `+keys our` in
213+dojo. You can inspect another ship's life and rift number by running `+keys
214+~sampel-palnet`. For information on what life and rift are, see [Guide to Breaches](@/docs/tutorials/guide-to-breaches.md).
215+
185216## DNS proxying {#dns-proxying}
186217
187218We have a system that lets you request a domain name for your ship in the form of `ship.arvo.network`, where `ship` is your ship's name minus the `~`. This allows users to access their ships remotely using Landscape, our graphical web interface.
@@ -282,6 +313,12 @@ Now, let's create a channel we can invite some friends to:
282313
283314Now you can tell your friends to `;join ~/~your-urbit/my-channel`.
284315
316+In order to see messages in `:chat-cli` you may need to do the following in Dojo:
317+
318+```
319+:chat-cli %connect
320+```
321+
285322### Hoon
286323
287324You can use Chat to evaluate Hoon code and share the results with everyone in a chat. To do so, preface your Hoon with `#`.
sass/_main.scss+66−25
@@ -97,11 +97,21 @@ figcaption.home {
9797 margin: 0 auto;
9898}
9999
100+// obj-fit contain util
101+
102+.obj-cover {
103+ object-fit: cover;
104+}
105+
100106a {
101107 color: inherit;
102108 text-decoration: none;
103109}
104110
111+b, strong {
112+ @extend .fw6;
113+}
114+
105115article {
106116 // default
107117 // links on body text
@@ -112,9 +122,6 @@ article {
112122 border-bottom: 0;
113123 }
114124 }
115− b, strong {
116− @extend .fw6;
117− }
118125 // post directories
119126 li {
120127 margin: 0rem 1rem 1rem 1rem;
@@ -149,6 +156,7 @@ footer nav {
149156 font-size: 1rem;
150157 position: absolute;
151158 right: -36px;
159+ top: 0;
152160 font-family: "Inter UI", sans-serif;
153161 }
154162 &.next p:first-of-type::before {
@@ -156,6 +164,7 @@ footer nav {
156164 font-size: 1rem;
157165 position: absolute;
158166 left: -36px;
167+ top: 0;
159168 font-family: "Inter UI", sans-serif;
160169 }
161170}
@@ -164,7 +173,6 @@ footer nav {
164173
165174body.essay {
166175 h1 {
167− font-size: 1rem;
168176 max-width: 95vw;
169177 }
170178 &:not(.bg-white) {
@@ -187,9 +195,33 @@ body.essay {
187195 color: black;
188196 }
189197 }
198+
199+ h2 {
200+ margin-top: 4rem;
201+ }
202+
203+ blockquote {
204+ border-left: 1px solid black;
205+ padding-left: 2rem;
206+ font-style: italic;
207+ margin-bottom: 0;
208+ }
209+
190210 img {
191211 display: block;
192− // margin: 0 auto;
212+ }
213+ div.footnote-definition {
214+ &[id="0"] {
215+ margin-top: 4rem;
216+ padding-top: 2rem;
217+ border-top: 1px solid black;
218+ }
219+ p {
220+ display: inline;
221+ }
222+ &:not([id="0"]) {
223+ margin: 2rem 0;
224+ }
193225 }
194226}
195227
@@ -211,6 +243,17 @@ ul p {
211243figure {
212244 margin: 0;
213245}
246+ // blockquote reset
247+blockquote {
248+ margin-block-start: 0;
249+ margin-block-end: 0;
250+ margin-inline-start: 0;
251+ margin-inline-end: 0;
252+ margin-bottom: 2rem;
253+ cite {
254+ font-style: normal;
255+ }
256+}
214257
215258 // images for posts
216259img {
@@ -223,13 +266,6 @@ h1, h2, h3, h4, h5 {
223266 margin-block-end: 0;
224267 @extend .fw6;
225268 font-size: 1rem;
226−}
227−
228−h1, .f1 {
229− @extend .lh-solid;
230−}
231−
232−h2, .f2, h3, .f3 {
233269 @extend .lh-title;
234270}
235271
@@ -241,12 +277,6 @@ h4 {
241277 padding: 1rem 0 0.5rem 0;
242278}
243279
244− // author and ship styling
245−span[rel=author] {
246− @extend .fw4;
247− margin-right: 5px;
248−}
249−
250280address {
251281 display: inline;
252282 font-style: normal;
@@ -258,11 +288,19 @@ ul.posts, nav ul, nav li {
258288}
259289
260290ul.posts li:not(:first-child) {
261− margin:2rem 0 2rem 0;
291+ margin:6rem 0 6rem 0;
262292}
263293
264294ul.posts li:first-child {
265− margin: 0 0 2rem 0;
295+ margin: 0 0 6rem 0;
296+}
297+
298+ul.posts.update li:first-child {
299+ margin: 0 0 2rem 0;
300+}
301+
302+ul.posts.update li:not(:first-child) {
303+ margin: 2rem 0;
266304}
267305
268306nav ul.docs {
@@ -283,10 +321,6 @@ nav.previous, nav.next {
283321 // min-width: 110px;
284322 text-align: left;
285323 background: transparent;
286− span#search-icon {
287− display: inline-block;
288− transform: translate(-4px, 2px) rotate(-45deg);
289− }
290324 span.search-slash {
291325 font-size: 0.75em;
292326 position: absolute;
@@ -382,7 +416,6 @@ input[type="search"] {
382416 }
383417 }
384418 .glossary-results__item {
385− padding: 0 1rem 0 1rem;
386419 &:hover {
387420 background-color: #F9F9F9;
388421 }
@@ -553,6 +586,14 @@ nav.docs details {
553586 }
554587}
555588
589+// are.na embeds
590+
591+iframe.arena-iframe {
592+ border: 0;
593+ min-height: 34em;
594+ width: 100%;
595+}
596+
556597// youtube
557598
558599.video-container {
static/glossary.jsnew file+5737
@@ -0,0 +1,5737 @@
1+var glossary = [
2+ // runes
3+ {
4+ "name": "dot",
5+ "symbol": ".",
6+ "usage": "Nock",
7+ "link": "/docs/reference/hoon-expressions/rune/dot/",
8+ "desc": "Runes used for carrying out Nock operations in Hoon."
9+ },
10+ {
11+ "name": "dotket",
12+ "symbol": ".^",
13+ "usage": "Nock",
14+ "link": "/docs/reference/hoon-expressions/rune/dot/#dotket",
15+ "desc": "<code>[%dtkt p=spec q=hoon]</code>: load from the Arvo namespace with a fake Nock instruction: 'Nock <code>12</code>''."
16+ },
17+ {
18+ "name": "dotlus",
19+ "symbol": ".+",
20+ "usage": "Nock",
21+ "link": "/docs/reference/hoon-expressions/rune/dot/#dotlus",
22+ "desc": "<code>[%dtls p=hoon]</code>: increment an atom with Nock <code>4</code>."
23+ },
24+ {
25+ "name": "dottar",
26+ "symbol": ".*",
27+ "usage": "Nock",
28+ "link": "/docs/reference/hoon-expressions/rune/dot/#dottar",
29+ "desc": "<code>[%dttr p=hoon q=hoon]</code>: evaluate with Nock <code>2</code>."
30+ },
31+ {
32+ "name": "dottis",
33+ "symbol": ".=",
34+ "usage": "Nock",
35+ "link": "/docs/reference/hoon-expressions/rune/dot/#dottis",
36+ "desc": "<code>[%dtts p=hoon q=hoon]</code>: test for equality with Nock <code>5</code>."
37+ },
38+ {
39+ "name": "dotwut",
40+ "symbol": ".?",
41+ "usage": "Nock",
42+ "link": "/docs/reference/hoon-expressions/rune/dot/#dotwut",
43+ "desc": "<code>[%dtwt p=hoon]</code>: test for cell or atom with Nock <code>3</code>."
44+ },
45+ {
46+ "name": "zap",
47+ "symbol": "!",
48+ "usage": "wild",
49+ "link": "/docs/reference/hoon-expressions/rune/zap/",
50+ "desc": "Wildcard category. Expressions that don't fit anywhere else go here."
51+ },
52+ {
53+ "name": "zapgar",
54+ "symbol": "!>",
55+ "usage": "wild",
56+ "link": "/docs/reference/hoon-expressions/rune/zap/#zapgar",
57+ "desc": "<code>[%zpgr p=hoon]</code>: wrap a noun in its type."
58+ },
59+ {
60+ "name": "zapgal",
61+ "symbol": "!<",
62+ "usage": "wild",
63+ "link": "/docs/reference/hoon-expressions/rune/zap/#zapgal",
64+ "desc": "<code>[%zpld p=spec q=hoon]</code>: extracts typed value from a vase."
65+ },
66+ {
67+ "name": "zapcol",
68+ "symbol": "!:",
69+ "usage": "wild",
70+ "link": "/docs/reference/hoon-expressions/rune/zap/#zapcol",
71+ "desc": "<code>[%dbug p=hoon]</code>: turn on stack trace"
72+ },
73+ {
74+ "name": "zapdot",
75+ "symbol": "!.",
76+ "usage": "wild",
77+ "link": "/docs/reference/hoon-expressions/rune/zap/#zapdot",
78+ "desc": "Turn off stack trace for a subexpression <code>p</code>"
79+ },
80+ {
81+ "name": "zaptis",
82+ "symbol": "!=",
83+ "usage": "wild",
84+ "link": "/docs/reference/hoon-expressions/rune/zap/#zaptis",
85+ "desc": "<code>[%zpts p=hoon]</code>: make the Nock formula for a Hoon expression."
86+ },
87+ {
88+ "name": "zapwut",
89+ "symbol": "!?",
90+ "usage": "wild",
91+ "link": "/docs/reference/hoon-expressions/rune/zap/#zapwut",
92+ "desc": "<code>[%zpwt p=@ q=hoon]</code>: restrict Hoon version."
93+ },
94+ {
95+ "name": "zapzap",
96+ "symbol": "!!",
97+ "usage": "wild",
98+ "link": "/docs/reference/hoon-expressions/rune/zap/#zapzap",
99+ "desc": "<code>[%zpzp ~]</code>: crash."
100+ },
101+ {
102+ "name": "tis",
103+ "symbol": "=",
104+ "usage": "Subject Modification",
105+ "link": "/docs/reference/hoon-expressions/rune/tis/",
106+ "desc": "Runes used to modify the subject."
107+ },
108+ {
109+ "name": "tisgar",
110+ "symbol": "=>",
111+ "usage": "Subject Modification",
112+ "link": "/docs/reference/hoon-expressions/rune/tis/#tisgar",
113+ "desc": "<code>[%tsgr p=hoon q=hoon]</code>: compose two expressions."
114+ },
115+ {
116+ "name": "tisbar",
117+ "symbol": "=|",
118+ "usage": "Subject Modification",
119+ "link": "/docs/reference/hoon-expressions/rune/tis/#tisbar",
120+ "desc": "<code>[%tsbr p=spec q=hoon]</code>: combine a default type value with the subject."
121+ },
122+ {
123+ "name": "tiscol",
124+ "symbol": "=:",
125+ "usage": "Subject Modification",
126+ "link": "/docs/reference/hoon-expressions/rune/tis/#tiscol",
127+ "desc": "<code>[%tscl p=(list (pair wing hoon)) q=hoon]</code>: change multiple legs in the subject."
128+ },
129+ {
130+ "name": "tiscom",
131+ "symbol": "=,",
132+ "usage": "Subject Modification",
133+ "link": "/docs/reference/hoon-expressions/rune/tis/#tiscom",
134+ "desc": "<code>[%tscm p=hoon q=hoon]</code>: expose namespace"
135+ },
136+ {
137+ "name": "tisdot",
138+ "symbol": "=.",
139+ "usage": "Subject Modification",
140+ "link": "/docs/reference/hoon-expressions/rune/tis/#tisdot",
141+ "desc": "<code>[%tsdt p=wing q=hoon r=hoon]</code>: change one leg in the subject."
142+ },
143+ {
144+ "name": "tishep",
145+ "symbol": "=-",
146+ "usage": "Subject Modification",
147+ "link": "/docs/reference/hoon-expressions/rune/tis/#tishep",
148+ "desc": "<code>[%tshp p=hoon q=hoon]</code>: combine a new noun with the subject, inverted."
149+ },
150+ {
151+ "name": "tisket",
152+ "symbol": "=^",
153+ "usage": "Subject Modification",
154+ "link": "/docs/reference/hoon-expressions/rune/tis/#tisket",
155+ "desc": "<code>[%tskt p=skin q=wing r=hoon s=hoon]</code>: pin the head of a pair; change"
156+ },
157+ {
158+ "name": "tisgal",
159+ "symbol": "=<",
160+ "usage": "Subject Modification",
161+ "link": "/docs/reference/hoon-expressions/rune/tis/#tisgal",
162+ "desc": "<code>[%tsgl p=hoon q=hoon]</code>: compose two expressions, inverted."
163+ },
164+ {
165+ "name": "tislus",
166+ "symbol": "=+",
167+ "usage": "Subject Modification",
168+ "link": "/docs/reference/hoon-expressions/rune/tis/#tislus",
169+ "desc": "<code>[%tsls p=hoon q=hoon]</code>: combine a new noun with the subject."
170+ },
171+ {
172+ "name": "tismic",
173+ "symbol": "=;",
174+ "usage": "Subject Modification",
175+ "link": "/docs/reference/hoon-expressions/rune/tis/#tismic",
176+ "desc": "<code>[%tssm p=skin q=hoon r=hoon]</code>: combine a named noun with the subject, possibly with type annotation; inverted order."
177+ },
178+ {
179+ "name": "tisfas",
180+ "symbol": "=/",
181+ "usage": "Subject Modification",
182+ "link": "/docs/reference/hoon-expressions/rune/tis/#tisfas",
183+ "desc": "<code>[%tsfs p=skin q=hoon r=hoon]</code>: combine a named noun with the subject, possibly with type annotation."
184+ },
185+ {
186+ "name": "tissig",
187+ "symbol": "=~",
188+ "usage": "Subject Modification",
189+ "link": "/docs/reference/hoon-expressions/rune/tis/#tissig",
190+ "desc": "<code>[%tssg p=(list hoon)]</code>: compose many expressions."
191+ },
192+ {
193+ "name": "tistar",
194+ "symbol": "=*",
195+ "usage": "Subject Modification",
196+ "link": "/docs/reference/hoon-expressions/rune/tis/#tistar",
197+ "desc": "<code>[%tstr p=term q=hoon r=hoon]</code>: define an alias."
198+ },
199+ {
200+ "name": "tiswut",
201+ "symbol": "=?",
202+ "usage": "Subject Modification",
203+ "link": "/docs/reference/hoon-expressions/rune/tis/#tiswut",
204+ "desc": "<code>[$tswt p=wing q=hoon r=hoon s=hoon]</code>: conditionally change one leg in the subject."
205+ },
206+ {
207+ "name": "wut",
208+ "symbol": "?",
209+ "usage": "Conditionals",
210+ "link": "/docs/reference/hoon-expressions/rune/wut/",
211+ "desc": "Runes used for branching on conditionals."
212+ },
213+ {
214+ "name": "wutgar",
215+ "symbol": "?>",
216+ "usage": "Conditionals",
217+ "link": "/docs/reference/hoon-expressions/rune/wut/#wutgar",
218+ "desc": "<code>[%wtbn p=hoon q=hoon]</code>: positive assertion."
219+ },
220+ {
221+ "name": "wutbar",
222+ "symbol": "?|",
223+ "usage": "Conditionals",
224+ "link": "/docs/reference/hoon-expressions/rune/wut/#wutbar",
225+ "desc": "<code>[%wtbr p=(list hoon)]</code>: logical OR."
226+ },
227+ {
228+ "name": "wutcol",
229+ "symbol": "?:",
230+ "usage": "Conditionals",
231+ "link": "/docs/reference/hoon-expressions/rune/wut/#wutcol",
232+ "desc": "<code>[%wtcl p=hoon q=hoon r=hoon]</code>: branch on a boolean test."
233+ },
234+ {
235+ "name": "wutdot",
236+ "symbol": "?.",
237+ "usage": "Conditionals",
238+ "link": "/docs/reference/hoon-expressions/rune/wut/#wutdot",
239+ "desc": "<code>[%wtdt p=hoon q=hoon r=hoon]</code>: branch on a boolean test, inverted."
240+ },
241+ {
242+ "name": "wuthep",
243+ "symbol": "?-",
244+ "usage": "Conditionals",
245+ "link": "/docs/reference/hoon-expressions/rune/wut/#wuthep",
246+ "desc": "<code>[%wthp p=wing q=(list (pair spec value))]</code>: switch against a union, with no default."
247+ },
248+ {
249+ "name": "wutket",
250+ "symbol": "?^",
251+ "usage": "Conditionals",
252+ "link": "/docs/reference/hoon-expressions/rune/wut/#wutket",
253+ "desc": "<code>[%wtkt p=wing q=hoon r=hoon]</code>: branch on whether a wing"
254+ },
255+ {
256+ "name": "wutgal",
257+ "symbol": "?<",
258+ "usage": "Conditionals",
259+ "link": "/docs/reference/hoon-expressions/rune/wut/#wutgal",
260+ "desc": "<code>[%wtgl p=hoon q=hoon]</code>: negative assertion."
261+ },
262+ {
263+ "name": "wutlus",
264+ "symbol": "?+",
265+ "usage": "Conditionals",
266+ "link": "/docs/reference/hoon-expressions/rune/wut/#wutlus",
267+ "desc": "<code>[%wtls p=wing q=hoon r=(list (pair spec hoon))]</code>: switch against"
268+ },
269+ {
270+ "name": "wutpam",
271+ "symbol": "?&",
272+ "usage": "Conditionals",
273+ "link": "/docs/reference/hoon-expressions/rune/wut/#wutpam",
274+ "desc": "<code>[%wtpd p=(list hoon)]</code>: logical AND."
275+ },
276+ {
277+ "name": "wutsig",
278+ "symbol": "?~",
279+ "usage": "Conditionals",
280+ "link": "/docs/reference/hoon-expressions/rune/wut/#wutsig",
281+ "desc": "<code>[%wtsg p=wing q=hoon r=hoon]</code>: branch on whether a wing of the subject is null."
282+ },
283+ {
284+ "name": "wuttis",
285+ "symbol": "?=",
286+ "usage": "Conditionals",
287+ "link": "/docs/reference/hoon-expressions/rune/wut/#wuttis",
288+ "desc": "<code>[%wtts p=spec q=wing]</code>: test pattern match."
289+ },
290+ {
291+ "name": "wutpat",
292+ "symbol": "?@",
293+ "usage": "Conditionals",
294+ "link": "/docs/reference/hoon-expressions/rune/wut/#wutpat",
295+ "desc": "<code>[%wtpt p=wing q=hoon r=hoon]</code>: branch on whether a wing of the subject is an atom."
296+ },
297+ {
298+ "name": "wutzap",
299+ "symbol": "?!",
300+ "usage": "Conditionals",
301+ "link": "/docs/reference/hoon-expressions/rune/wut/#wutzap",
302+ "desc": "<code>[%wtzp p=hoon]</code>: logical NOT."
303+ },
304+ {
305+ "name": "bar",
306+ "symbol": "|",
307+ "usage": "Cores",
308+ "link": "/docs/reference/hoon-expressions/rune/bar/",
309+ "desc": "Runes used to produce cores."
310+ },
311+ {
312+ "name": "barcab",
313+ "symbol": "|_",
314+ "usage": "Cores",
315+ "link": "/docs/reference/hoon-expressions/rune/bar/#barcab",
316+ "desc": "Produce a **door** (a core with a sample)."
317+ },
318+ {
319+ "name": "barcen",
320+ "symbol": "|%",
321+ "usage": "Cores",
322+ "link": "/docs/reference/hoon-expressions/rune/bar/#barcen",
323+ "desc": "Produce a core, <code>[battery payload]</code>."
324+ },
325+ {
326+ "name": "barcol",
327+ "symbol": "|:",
328+ "usage": "Cores",
329+ "link": "/docs/reference/hoon-expressions/rune/bar/#barcol",
330+ "desc": "Produce a gate with a custom sample."
331+ },
332+ {
333+ "name": "bardot",
334+ "symbol": "|.",
335+ "usage": "Cores",
336+ "link": "/docs/reference/hoon-expressions/rune/bar/#bardot",
337+ "desc": "Produce a trap (a core with one arm <code>$</code>)."
338+ },
339+ {
340+ "name": "barhep",
341+ "symbol": "|-",
342+ "usage": "Cores",
343+ "link": "/docs/reference/hoon-expressions/rune/bar/#barhep",
344+ "desc": "Produce a trap (a core with one arm <code>$</code>) and evaluate it."
345+ },
346+ {
347+ "name": "barket",
348+ "symbol": "|^",
349+ "usage": "Cores",
350+ "link": "/docs/reference/hoon-expressions/rune/bar/#barket",
351+ "desc": "Produce a core whose battery includes a <code>$</code> arm and compute the latter."
352+ },
353+ {
354+ "name": "barsig",
355+ "symbol": "|~",
356+ "usage": "Cores",
357+ "link": "/docs/reference/hoon-expressions/rune/bar/#barsig",
358+ "desc": "Produce an iron gate."
359+ },
360+ {
361+ "name": "bartar",
362+ "symbol": "|*",
363+ "usage": "Cores",
364+ "link": "/docs/reference/hoon-expressions/rune/bar/#bartar",
365+ "desc": "Produce a wet gate (one-armed core with sample)."
366+ },
367+ {
368+ "name": "bartis",
369+ "symbol": "|=",
370+ "usage": "Cores",
371+ "link": "/docs/reference/hoon-expressions/rune/bar/#bartis",
372+ "desc": "Produce a gate (a one-armed core with a sample)."
373+ },
374+ {
375+ "name": "barpat",
376+ "symbol": "|@",
377+ "usage": "Cores",
378+ "link": "/docs/reference/hoon-expressions/rune/bar/#barpat",
379+ "desc": "Produce a 'wet' core <code>[battery payload]</code>."
380+ },
381+ {
382+ "name": "barwut",
383+ "symbol": "|?",
384+ "usage": "Cores",
385+ "link": "/docs/reference/hoon-expressions/rune/bar/#barwut",
386+ "desc": "Produce a lead trap."
387+ },
388+ {
389+ "name": "lus",
390+ "symbol": "+",
391+ "usage": "Arms",
392+ "link": "/docs/reference/hoon-expressions/rune/lus/",
393+ "desc": "Runes used to define arms in a core."
394+ },
395+ {
396+ "name": "lusbar",
397+ "symbol": "+|",
398+ "usage": "Arms",
399+ "link": "/docs/reference/hoon-expressions/rune/lus/#lusbar",
400+ "desc": "Chapter label."
401+ },
402+ {
403+ "name": "lusbuc",
404+ "symbol": "+$",
405+ "usage": "Arms",
406+ "link": "/docs/reference/hoon-expressions/rune/lus/#lusbuc",
407+ "desc": "Produce a structure arm (type definition)."
408+ },
409+ {
410+ "name": "luslus",
411+ "symbol": "++",
412+ "usage": "Arms",
413+ "link": "/docs/reference/hoon-expressions/rune/lus/#luslus",
414+ "desc": "Produce a normal arm."
415+ },
416+ {
417+ "name": "lustar",
418+ "symbol": "+*",
419+ "usage": "Arms",
420+ "link": "/docs/reference/hoon-expressions/rune/lus/#lustar",
421+ "desc": "Produce a type constructor arm."
422+ },
423+ {
424+ "name": "col",
425+ "symbol": ":",
426+ "usage": "Cells",
427+ "link": "/docs/reference/hoon-expressions/rune/col/",
428+ "desc": "Runes used to produce cells, which are pairs of nouns."
429+ },
430+ {
431+ "name": "colcab",
432+ "symbol": ":_",
433+ "usage": "Cells",
434+ "link": "/docs/reference/hoon-expressions/rune/col/#colcab",
435+ "desc": "<code>[%clcb p=hoon q=hoon]</code>; construct a cell, inverted."
436+ },
437+ {
438+ "name": "colcol",
439+ "symbol": "::",
440+ "usage": "Cells",
441+ "link": "/docs/reference/hoon-expressions/rune/col/#colcol",
442+ "desc": "Code comment."
443+ },
444+ {
445+ "name": "colhep",
446+ "symbol": ":-",
447+ "usage": "Cells",
448+ "link": "/docs/reference/hoon-expressions/rune/col/#colhep",
449+ "desc": "<code>[%clhp p=hoon q=hoon]</code>: construct a cell (2-tuple)."
450+ },
451+ {
452+ "name": "colket",
453+ "symbol": ":^",
454+ "usage": "Cells",
455+ "link": "/docs/reference/hoon-expressions/rune/col/#colket",
456+ "desc": "<code>[%clkt p=hoon q=hoon r=hoon s=hoon]</code>: construct a quadruple (4-tuple)."
457+ },
458+ {
459+ "name": "collus",
460+ "symbol": ":+",
461+ "usage": "Cells",
462+ "link": "/docs/reference/hoon-expressions/rune/col/#collus",
463+ "desc": "<code>[%clls p=hoon q=hoon r=hoon]</code>: construct a triple (3-tuple)."
464+ },
465+ {
466+ "name": "colsig",
467+ "symbol": ":~",
468+ "usage": "Cells",
469+ "link": "/docs/reference/hoon-expressions/rune/col/#colsig",
470+ "desc": "<code>[%clsg p=(list hoon)]</code>: construct a null-terminated list."
471+ },
472+ {
473+ "name": "coltar",
474+ "symbol": ":*",
475+ "usage": "Cells",
476+ "link": "/docs/reference/hoon-expressions/rune/col/#coltar",
477+ "desc": "<code>[%cltr p=(list hoon)]</code>: construct an n-tuple."
478+ },
479+ {
480+ "name": "cen",
481+ "symbol": "%",
482+ "usage": "Calls",
483+ "link": "/docs/reference/hoon-expressions/rune/cen/",
484+ "desc": "Runes used for making function calls in Hoon."
485+ },
486+ {
487+ "name": "cencab",
488+ "symbol": "%_",
489+ "usage": "Calls",
490+ "link": "/docs/reference/hoon-expressions/rune/cen/#cencab",
491+ "desc": "Resolve a wing with changes, preserving type."
492+ },
493+ {
494+ "name": "cencol",
495+ "symbol": "%:",
496+ "usage": "Calls",
497+ "link": "/docs/reference/hoon-expressions/rune/cen/#cencol",
498+ "desc": "Call a gate with many arguments."
499+ },
500+ {
501+ "name": "cendot",
502+ "symbol": "%.",
503+ "usage": "Calls",
504+ "link": "/docs/reference/hoon-expressions/rune/cen/#cendot",
505+ "desc": "Call a gate (function), inverted."
506+ },
507+ {
508+ "name": "cenhep",
509+ "symbol": "%-",
510+ "usage": "Calls",
511+ "link": "/docs/reference/hoon-expressions/rune/cen/#cenhep",
512+ "desc": "Call a gate (function)."
513+ },
514+ {
515+ "name": "cenket",
516+ "symbol": "%^",
517+ "usage": "Calls",
518+ "link": "/docs/reference/hoon-expressions/rune/cen/#cenket",
519+ "desc": "Call gate with triple sample."
520+ },
521+ {
522+ "name": "cenlus",
523+ "symbol": "%+",
524+ "usage": "Calls",
525+ "link": "/docs/reference/hoon-expressions/rune/cen/#cenlus",
526+ "desc": "Call gate with a cell sample."
527+ },
528+ {
529+ "name": "censig",
530+ "symbol": "%~",
531+ "usage": "Calls",
532+ "link": "/docs/reference/hoon-expressions/rune/cen/#censig",
533+ "desc": "Evaluate an arm in a door."
534+ },
535+ {
536+ "name": "centar",
537+ "symbol": "%*",
538+ "usage": "Calls",
539+ "link": "/docs/reference/hoon-expressions/rune/cen/#centar",
540+ "desc": "Evaluate an expression, then resolve a wing with changes."
541+ },
542+ {
543+ "name": "centis",
544+ "symbol": "%=",
545+ "usage": "Calls",
546+ "link": "/docs/reference/hoon-expressions/rune/cen/#centis",
547+ "desc": "Resolve a wing with changes."
548+ },
549+ {
550+ "name": "ket",
551+ "symbol": "^",
552+ "usage": "Casts",
553+ "link": "/docs/reference/hoon-expressions/rune/ket/",
554+ "desc": "Runes that let us adjust types without violating type constraints."
555+ },
556+ {
557+ "name": "ketbar",
558+ "symbol": "^|",
559+ "usage": "Casts",
560+ "link": "/docs/reference/hoon-expressions/rune/ket/#ketbar",
561+ "desc": "<code>[%ktbr p=hoon]</code>: convert a gold core to an iron core (contravariant)."
562+ },
563+ {
564+ "name": "ketcol",
565+ "symbol": "^:",
566+ "usage": "Casts",
567+ "link": "/docs/reference/hoon-expressions/rune/ket/#ketcol",
568+ "desc": "<code>[%ktcl p=spec]</code>: 'factory' gate for type <code>p</code>."
569+ },
570+ {
571+ "name": "ketdot",
572+ "symbol": "^.",
573+ "usage": "Casts",
574+ "link": "/docs/reference/hoon-expressions/rune/ket/#ketdot",
575+ "desc": "<code>[%ktdt p=hoon q=hoon]</code>: typecast on value produced by passing <code>q</code> to <code>p</code>."
576+ },
577+ {
578+ "name": "kethep",
579+ "symbol": "^-",
580+ "usage": "Casts",
581+ "link": "/docs/reference/hoon-expressions/rune/ket/#kethep",
582+ "desc": "<code>[%kthp p=spec q=hoon]</code>: typecast by explicit type label."
583+ },
584+ {
585+ "name": "ketlus",
586+ "symbol": "^+",
587+ "usage": "Casts",
588+ "link": "/docs/reference/hoon-expressions/rune/ket/#ketlus",
589+ "desc": "<code>[%ktls p=hoon q=hoon]</code>: typecast by inferred type."
590+ },
591+ {
592+ "name": "ketpam",
593+ "symbol": "^&",
594+ "usage": "Casts",
595+ "link": "/docs/reference/hoon-expressions/rune/ket/#ketpam",
596+ "desc": "<code>[%ktpd p=hoon]</code>: convert a core to a zinc core (covariant)."
597+ },
598+ {
599+ "name": "ketsig",
600+ "symbol": "^~",
601+ "usage": "Casts",
602+ "link": "/docs/reference/hoon-expressions/rune/ket/#ketsig",
603+ "desc": "<code>[%ktsg p=hoon]</code>: fold constant at compile time."
604+ },
605+ {
606+ "name": "kettar",
607+ "symbol": "^*",
608+ "usage": "Casts",
609+ "link": "/docs/reference/hoon-expressions/rune/ket/#kettar",
610+ "desc": "<code>[%kttr p=spec]</code>: Produce example type value."
611+ },
612+ {
613+ "name": "kettis",
614+ "symbol": "^=",
615+ "usage": "Casts",
616+ "link": "/docs/reference/hoon-expressions/rune/ket/#kettis",
617+ "desc": "<code>[%ktts p=skin q=hoon]</code>: Bind name to a value."
618+ },
619+ {
620+ "name": "ketwut",
621+ "symbol": "^?",
622+ "usage": "Casts",
623+ "link": "/docs/reference/hoon-expressions/rune/ket/#ketwut",
624+ "desc": "<code>[%ktwt p=hoon]</code>: convert any core to a lead core (bivariant)."
625+ },
626+ {
627+ "name": "buc",
628+ "symbol": "$",
629+ "usage": "Structures",
630+ "link": "/docs/reference/hoon-expressions/rune/buc/",
631+ "desc": "Runes used for defining custom types."
632+ },
633+ {
634+ "name": "buccab",
635+ "symbol": "$_",
636+ "usage": "Structures",
637+ "link": "/docs/reference/hoon-expressions/rune/buc/#buccab",
638+ "desc": "<code>[%bscb p=hoon]</code>: structure that normalizes to an example."
639+ },
640+ {
641+ "name": "buccen",
642+ "symbol": "$%",
643+ "usage": "Structures",
644+ "link": "/docs/reference/hoon-expressions/rune/buc/#buccen",
645+ "desc": "<code>[%bscn p=(list spec)]</code>: structure which recognizes a union tagged by head atom."
646+ },
647+ {
648+ "name": "buccol",
649+ "symbol": "$:",
650+ "usage": "Structures",
651+ "link": "/docs/reference/hoon-expressions/rune/buc/#buccol",
652+ "desc": "<code>[%bscl p=(list spec)]</code>: form a cell type."
653+ },
654+ {
655+ "name": "bucgal",
656+ "symbol": "$<",
657+ "usage": "Structures",
658+ "link": "/docs/reference/hoon-expressions/rune/buc/#bucgal",
659+ "desc": "<code>[%bsld p=spec q=spec]</code>: restrict a mold by excluding some given mold."
660+ },
661+ {
662+ "name": "bucgar",
663+ "symbol": "$>",
664+ "usage": "Structures",
665+ "link": "/docs/reference/hoon-expressions/rune/buc/#bucgar",
666+ "desc": "<code>[%bshp p=spec q=spec]</code>: filter a mold to obtain a new mold."
667+ },
668+ {
669+ "name": "buchep",
670+ "symbol": "$-",
671+ "usage": "Structures",
672+ "link": "/docs/reference/hoon-expressions/rune/buc/#buchep",
673+ "desc": "<code>[%bshp p=spec q=spec]</code>: structure that normalizes to an example gate."
674+ },
675+ {
676+ "name": "bucket",
677+ "symbol": "$^",
678+ "usage": "Structures",
679+ "link": "/docs/reference/hoon-expressions/rune/buc/#bucket",
680+ "desc": "<code>[%bskt p=spec q=spec]</code>: structure which normalizes a union tagged by head depth (cell)."
681+ },
682+ {
683+ "name": "bucsig",
684+ "symbol": "$~",
685+ "usage": "Structures",
686+ "link": "/docs/reference/hoon-expressions/rune/buc/#bucsig",
687+ "desc": "<code>[%bssg p=hoon q=spec]</code>: define a custom type default value"
688+ },
689+ {
690+ "name": "bucpat",
691+ "symbol": "$@",
692+ "usage": "Structures",
693+ "link": "/docs/reference/hoon-expressions/rune/buc/#bucpat",
694+ "desc": "<code>[%bsvt p=spec q=spec]</code>: structure which normalizes a union tagged by head depth (atom)."
695+ },
696+ {
697+ "name": "buctis",
698+ "symbol": "$=",
699+ "usage": "Structures",
700+ "link": "/docs/reference/hoon-expressions/rune/buc/#buctis",
701+ "desc": "<code>[%bsts p=skin q=spec]</code>: structure which wraps a face around another structure."
702+ },
703+ {
704+ "name": "bucwut",
705+ "symbol": "$?",
706+ "usage": "Structures",
707+ "link": "/docs/reference/hoon-expressions/rune/buc/#bucwut",
708+ "desc": "<code>[%bswt p=(list spec)]</code>: form a type from a union of other types."
709+ },
710+ {
711+ "name": "mic",
712+ "symbol": ";",
713+ "usage": "Make",
714+ "link": "/docs/reference/hoon-expressions/rune/mic/",
715+ "desc": "Miscellaneous useful macros."
716+ },
717+ {
718+ "name": "miccol",
719+ "symbol": ";:",
720+ "usage": "Make",
721+ "link": "/docs/reference/hoon-expressions/rune/mic/#miccol",
722+ "desc": "<code>[%mccl p=hoon q=(list hoon)]</code>: call a binary function as an n-ary function."
723+ },
724+ {
725+ "name": "miclus",
726+ "symbol": ";+",
727+ "usage": "Make",
728+ "link": "/docs/reference/hoon-expressions/rune/mic/#miclus",
729+ "desc": "make a single XML node (Sail)"
730+ },
731+ {
732+ "name": "micmic",
733+ "symbol": ";;",
734+ "usage": "Make",
735+ "link": "/docs/reference/hoon-expressions/rune/mic/#micmic",
736+ "desc": "<code>[%mcmc p=spec q=hoon]</code>: normalize with a mold, asserting fixpoint."
737+ },
738+ {
739+ "name": "micfas",
740+ "symbol": ";/",
741+ "usage": "Make",
742+ "link": "/docs/reference/hoon-expressions/rune/mic/#micfas",
743+ "desc": "<code>[%mcnt p=hoon]</code>: tape as XML element."
744+ },
745+ {
746+ "name": "micsig",
747+ "symbol": ";~",
748+ "usage": "Make",
749+ "link": "/docs/reference/hoon-expressions/rune/mic/#micsig",
750+ "desc": "<code>[%mcsg p=hoon q=(list hoon)]</code>: glue a pipeline together with a"
751+ },
752+ {
753+ "name": "mictar",
754+ "symbol": ";*",
755+ "usage": "Make",
756+ "link": "/docs/reference/hoon-expressions/rune/mic/#mictar",
757+ "desc": "Make a list of XML nodes from complex Hoon expression (Sail)."
758+ },
759+ {
760+ "name": "mictis",
761+ "symbol": ";=",
762+ "usage": "Make",
763+ "link": "/docs/reference/hoon-expressions/rune/mic/#mictis",
764+ "desc": "Make a list of XML nodes (Sail)."
765+ },
766+ {
767+ "name": "sig",
768+ "symbol": "~",
769+ "usage": "Hints",
770+ "link": "/docs/reference/hoon-expressions/rune/sig/",
771+ "desc": "Runes that use Nock <code>11</code> to pass non-semantic info to the interpreter."
772+ },
773+ {
774+ "name": "siggar",
775+ "symbol": "~>",
776+ "usage": "Hints",
777+ "link": "/docs/reference/hoon-expressions/rune/sig/#siggar",
778+ "desc": "<code>[%sgbn p=$@(term [p=term q=hoon]) q=hoon]</code>: raw hint, applied"
779+ },
780+ {
781+ "name": "sigbar",
782+ "symbol": "~|",
783+ "usage": "Hints",
784+ "link": "/docs/reference/hoon-expressions/rune/sig/#sigbar",
785+ "desc": "<code>[%sgbr p=hoon q=hoon]</code>: tracing printf."
786+ },
787+ {
788+ "name": "sigbuc",
789+ "symbol": "~$",
790+ "usage": "Hints",
791+ "link": "/docs/reference/hoon-expressions/rune/sig/#sigbuc",
792+ "desc": "<code>[%sgbs p=term q=hoon]</code>: profiling hit counter."
793+ },
794+ {
795+ "name": "sigcab",
796+ "symbol": "~_",
797+ "usage": "Hints",
798+ "link": "/docs/reference/hoon-expressions/rune/sig/#sigcab",
799+ "desc": "<code>[%sgcb p=hoon q=hoon]</code>: user-formatted tracing printf."
800+ },
801+ {
802+ "name": "sigcen",
803+ "symbol": "~%",
804+ "usage": "Hints",
805+ "link": "/docs/reference/hoon-expressions/rune/sig/#sigcen",
806+ "desc": "<code>[%sgcn p=term q=wing r=(list [term hoon]) s=hoon]</code>: jet registration."
807+ },
808+ {
809+ "name": "siggal",
810+ "symbol": "~<",
811+ "usage": "Hints",
812+ "link": "/docs/reference/hoon-expressions/rune/sig/#siggal",
813+ "desc": "<code>[%sgld p=$@(term [p=term q=hoon]) q=hoon]</code>: raw hint, applied to product."
814+ },
815+ {
816+ "name": "siglus",
817+ "symbol": "~+",
818+ "usage": "Hints",
819+ "link": "/docs/reference/hoon-expressions/rune/sig/#siglus",
820+ "desc": "<code>[%sgls p=hoon]</code>: cache a computation."
821+ },
822+ {
823+ "name": "sigfas",
824+ "symbol": "~/",
825+ "usage": "Hints",
826+ "link": "/docs/reference/hoon-expressions/rune/sig/#sigfas",
827+ "desc": "<code>[%sgnt p=term q=hoon]</code>: jet registration for gate with"
828+ },
829+ {
830+ "name": "sigpam",
831+ "symbol": "~&",
832+ "usage": "Hints",
833+ "link": "/docs/reference/hoon-expressions/rune/sig/#sigpam",
834+ "desc": "<code>[%sgpd p=hoon q=hoon]</code>: debugging printf."
835+ },
836+ {
837+ "name": "sigtis",
838+ "symbol": "~=",
839+ "usage": "Hints",
840+ "link": "/docs/reference/hoon-expressions/rune/sig/#sigtis",
841+ "desc": "<code>[%sgts p=hoon q=hoon]</code>: detect duplicate."
842+ },
843+ {
844+ "name": "sigwut",
845+ "symbol": "~?",
846+ "usage": "Hints",
847+ "link": "/docs/reference/hoon-expressions/rune/sig/#sigwut",
848+ "desc": "<code>[%sgwt p=hoon q=hoon r=hoon]</code>: conditional debug printf."
849+ },
850+ {
851+ "name": "sigzap",
852+ "symbol": "~!",
853+ "usage": "Hints",
854+ "link": "/docs/reference/hoon-expressions/rune/sig/#sigzap",
855+ "desc": "<code>[%sgzp p=hoon q=hoon]</code>: print type on compilation fail."
856+ },
857+ {
858+ "name": "terminators",
859+ "symbol": "--,",
860+ "usage": "Terminators",
861+ "link": "/docs/reference/hoon-expressions/rune/terminators/",
862+ "desc": "Runes used to terminate expressions."
863+ },
864+ {
865+ "name": "hephep",
866+ "symbol": "--",
867+ "usage": "Terminators",
868+ "link": "/docs/reference/hoon-expressions/rune/terminators/#hephep",
869+ "desc": "The <code>--</code> rune is used to indicate the end of a core expression."
870+ },
871+ {
872+ "name": "tistis",
873+ "symbol": "==",
874+ "usage": "Terminators",
875+ "link": "/docs/reference/hoon-expressions/rune/terminators/#tistis",
876+ "desc": "The <code>==</code> rune is used to indicate the end of a 'jogging' or 'running' series of Hoon expressions."
877+ },
878+ {
879+ "name": "fas",
880+ "symbol": "/",
881+ "usage": "Ford",
882+ "link": "/docs/tutorials/arvo/ford/#ford-runes",
883+ "desc": "Runes specific to Ford, not considered to be Hoon runes."
884+ },
885+ {
886+ "name": "faslus",
887+ "symbol": "/+",
888+ "usage": "Ford",
889+ "link": "/docs/tutorials/arvo/ford/#faslus",
890+ "desc": "Ford rune. Import from <code>lib/</code>"
891+ },
892+ {
893+ "name": "fashep",
894+ "symbol": "/-",
895+ "usage": "Ford",
896+ "link": "/docs/tutorials/arvo/ford/#fashep",
897+ "desc": "Ford rune. Import from <code>sur/</code>"
898+ },
899+ {
900+ "name": "fassig",
901+ "symbol": "/~",
902+ "usage": "Ford",
903+ "link": "/docs/tutorials/arvo/ford/#fassig",
904+ "desc": "Ford rune. Twig by hand."
905+ },
906+ {
907+ "name": "fasfas",
908+ "symbol": "//",
909+ "usage": "Ford",
910+ "link": "/docs/tutorials/arvo/ford/#fasfas",
911+ "desc": "Ford rune. Include a file by relative path."
912+ },
913+ {
914+ "name": "fastis",
915+ "symbol": "/=",
916+ "usage": "Ford",
917+ "link": "/docs/tutorials/arvo/ford/#fastis",
918+ "desc": "Ford rune. Wrap a face around an included horn."
919+ },
920+ {
921+ "name": "fascol",
922+ "symbol": "/:",
923+ "usage": "Ford",
924+ "link": "/docs/tutorials/arvo/ford/#fascol",
925+ "desc": "Ford rune. Evaluate at path, and <code>/mark/</code> at current path"
926+ },
927+ {
928+ "name": "faszap",
929+ "symbol": "/!",
930+ "usage": "Ford",
931+ "link": "/docs/tutorials/arvo/ford/#faszap",
932+ "desc": "Ford rune. <code>/!mark/</code> evaluates as Hoon, then passes through mark."
933+ },
934+ {
935+ "name": "faspam",
936+ "symbol": "/&",
937+ "usage": "Ford",
938+ "link": "/docs/tutorials/arvo/ford/#faspam",
939+ "desc": "Ford rune. Pass through a series of marks."
940+ },
941+ {
942+ "name": "fasbar",
943+ "symbol": "/|",
944+ "usage": "Ford",
945+ "link": "/docs/tutorials/arvo/ford/#fasbar",
946+ "desc": "Ford rune. Short-circuiting 'or' "
947+ },
948+ {
949+ "name": "fascab",
950+ "symbol": "/_",
951+ "usage": "Ford",
952+ "link": "/docs/tutorials/arvo/ford/#fascab",
953+ "desc": "Ford rune. Runs horns on files in the current directory."
954+ },
955+ {
956+ "name": "fasmic",
957+ "symbol": "/;",
958+ "usage": "Ford",
959+ "link": "/docs/tutorials/arvo/ford/#fasmic",
960+ "desc": "Ford rune. Operate on."
961+ },
962+ {
963+ "name": "fascom",
964+ "symbol": "/,",
965+ "usage": "Ford",
966+ "link": "/docs/tutorials/arvo/ford/#fascom",
967+ "desc": "Ford rune. Switch by path."
968+ },
969+ {
970+ "name": "fasdot",
971+ "symbol": "/.",
972+ "usage": "Ford",
973+ "link": "/docs/tutorials/arvo/ford/#fasdot",
974+ "desc": "Ford rune. Produces a list from a sequence of horns."
975+ },
976+ {
977+ "name": "fasket",
978+ "symbol": "/^",
979+ "usage": "Ford",
980+ "link": "/docs/tutorials/arvo/ford/#fasket",
981+ "desc": "Ford rune. Casts the result of a horn to a mold."
982+ },
983+ {
984+ "name": "fashax",
985+ "symbol": "/#",
986+ "usage": "Ford",
987+ "link": "/docs/tutorials/arvo/ford/#fashax",
988+ "desc": "Ford rune. Inserts a dependency hash."
989+ },
990+ {
991+ "name": "fasbuc",
992+ "symbol": "/$",
993+ "usage": "Ford",
994+ "link": "/docs/tutorials/arvo/ford/#fasbuc",
995+ "desc": "Ford rune. Process extra arguments."
996+ },
997+ {
998+ "name": "fascen",
999+ "symbol": "/%",
1000+ "usage": "Ford",
1001+ "link": "/docs/tutorials/arvo/ford/#fascen",
1002+ "desc": "Ford rune. Propagate extra arguments into renderers."
1003+ },
1004+ // glossary starts here
1005+ {
1006+ "name": "ames",
1007+ "symbol": "",
1008+ "usage": "Arvo",
1009+ "link": "/docs/glossary/ames/",
1010+ "desc": "The name of the Urbit network and the vane that communicates over it."
1011+ },
1012+ {
1013+ "name": "aqua",
1014+ "symbol": "",
1015+ "usage": "Arvo",
1016+ "link": "/docs/glossary/aqua/",
1017+ "desc": "A virtualization tool whose primary purpose is testing and development."
1018+ },
1019+ {
1020+ "name": "arm",
1021+ "symbol": "",
1022+ "usage": "arm",
1023+ "link": "/docs/glossary/arm/",
1024+ "desc": "A Hoon expression encoded as a noun. Part of a core."
1025+ },
1026+ {
1027+ "name": "arvo",
1028+ "symbol": "",
1029+ "usage": "Arvo",
1030+ "link": "/docs/glossary/arvo/",
1031+ "desc": "The Urbit operating system and kernel."
1032+ },
1033+ {
1034+ "name": "atom",
1035+ "symbol": "",
1036+ "usage": "hoon-nock",
1037+ "link": "/docs/glossary/atom/",
1038+ "desc": "The most basic data type in Hoon and Nock, a non-negative integer of any size."
1039+ },
1040+ {
1041+ "name": "azimuth",
1042+ "symbol": "",
1043+ "usage": "azimuth",
1044+ "link": "/docs/glossary/azimuth/",
1045+ "desc": "Urbit's identity layer, built as a suite of smart contracts on the Ethereum blockchain."
1046+ },
1047+ {
1048+ "name": "behn",
1049+ "symbol": "",
1050+ "usage": "arvo",
1051+ "link": "/docs/glossary/behn/",
1052+ "desc": "Timing vane of Arvo. Allows for applications to schedule events."
1053+ },
1054+ {
1055+ "name": "battery",
1056+ "symbol": "",
1057+ "usage": "battery",
1058+ "link": "/docs/glossary/battery/",
1059+ "desc": "A collection of Hoon expressions stored at the head of a core."
1060+ },
1061+ {
1062+ "name": "bridge",
1063+ "symbol": "",
1064+ "usage": "azimuth",
1065+ "link": "/docs/glossary/bridge/",
1066+ "desc": "A client made for interacting with Azimuth."
1067+ },
1068+ {
1069+ "name": "censure",
1070+ "symbol": "",
1071+ "usage": "azimuth",
1072+ "link": "/docs/glossary/censure/",
1073+ "desc": "Allows stars and galaxies to assign negative reputation information to other points of equal or lower rank."
1074+ },
1075+ {
1076+ "name": "ceremony",
1077+ "symbol": "",
1078+ "usage": "azimuth",
1079+ "link": "/docs/glossary/ceremony/",
1080+ "desc": "The event that transferred custody of Azimuth identities from a centralized ledger to the Ethereum blockchain."
1081+ },
1082+ {
1083+ "name": "chat",
1084+ "symbol": "",
1085+ "usage": "arvo",
1086+ "link": "/docs/glossary/chat/",
1087+ "desc": "An application that handles communication between ships."
1088+ },
1089+ {
1090+ "name": "claims",
1091+ "symbol": "",
1092+ "usage": "azimuth",
1093+ "link": "/docs/glossary/claims/",
1094+ "desc": "Allows Urbit identities to make publicly visible assertions about their owner."
1095+ },
1096+ {
1097+ "name": "clay",
1098+ "symbol": "",
1099+ "usage": "arvo",
1100+ "link": "/docs/glossary/clay/",
1101+ "desc": "The filesystem and typed revision-control vane of Arvo."
1102+ },
1103+ {
1104+ "name": "comet",
1105+ "symbol": "",
1106+ "usage": "arvo",
1107+ "link": "/docs/glossary/comet/",
1108+ "desc": "A type of ship on the Urbit network."
1109+ },
1110+ {
1111+ "name": "core",
1112+ "symbol": "",
1113+ "usage": "core",
1114+ "link": "/docs/glossary/core/",
1115+ "desc": "A cell of battery and payload."
1116+ },
1117+ {
1118+ "name": "delegated sending",
1119+ "symbol": "",
1120+ "usage": "azimuth",
1121+ "link": "/docs/glossary/delegated-sending/",
1122+ "desc": "A method by which a star can distribute planets, assigning them to a delegated planet."
1123+ },
1124+ {
1125+ "name": "desk",
1126+ "symbol": "",
1127+ "usage": "arvo",
1128+ "link": "/docs/glossary/desk/",
1129+ "desc": "A revision-controlled branch of the Clay filesystem."
1130+ },
1131+ {
1132+ "name": "dill",
1133+ "symbol": "",
1134+ "usage": "arvo",
1135+ "link": "/docs/glossary/dill/",
1136+ "desc": "The terminal-driver vane of Arvo."
1137+ },
1138+ {
1139+ "name": "document vote",
1140+ "symbol": "",
1141+ "usage": "azimuth",
1142+ "link": "/docs/glossary/docvote/",
1143+ "desc": "A voting action taken by the Galactic Senate over Azimuth."
1144+ },
1145+ {
1146+ "name": "door",
1147+ "symbol": "",
1148+ "usage": "door",
1149+ "link": "/docs/glossary/door/",
1150+ "desc": "A core the payload of which is a cell of sample and context."
1151+ },
1152+ {
1153+ "name": "ecliptic",
1154+ "symbol": "",
1155+ "usage": "azimuth",
1156+ "link": "/docs/glossary/ecliptic/",
1157+ "desc": "A contract that sets the rules for what is and is not possible on Azimuth."
1158+ },
1159+ {
1160+ "name": "event log",
1161+ "symbol": "",
1162+ "usage": "arvo",
1163+ "link": "/docs/glossary/eventlog/",
1164+ "desc": "A totally ordered list of every single Arvo event a ship has undergone. A ship's state is a pure function of its event log."
1165+ },
1166+ {
1167+ "name": "eyre",
1168+ "symbol": "",
1169+ "usage": "arvo",
1170+ "link": "/docs/glossary/eyre/",
1171+ "desc": "The web-server vane of Arvo. Handles all HTTP messages."
1172+ },
1173+ {
1174+ "name": "ford",
1175+ "symbol": "",
1176+ "usage": "arvo",
1177+ "link": "/docs/glossary/ford/",
1178+ "desc": "The build-system vane of Arvo."
1179+ },
1180+ {
1181+ "name": "galaxy",
1182+ "symbol": "",
1183+ "usage": "arvo",
1184+ "link": "/docs/glossary/galaxy/",
1185+ "desc": "8-bit Urbit addresses, sitting at the top of the identity hierarchy, that vote on network changes and act as infrastructural nodes."
1186+ },
1187+ {
1188+ "name": "gall",
1189+ "symbol": "",
1190+ "usage": "arvo",
1191+ "link": "/docs/glossary/gall/",
1192+ "desc": "The application-management vane of Arvo. Userspace applications are stopped, started, and sandboxed by Gall."
1193+ },
1194+ {
1195+ "name": "gate",
1196+ "symbol": "",
1197+ "usage": "gate",
1198+ "link": "/docs/glossary/gate/",
1199+ "desc": "A core with one arm named $. The Hoon equivalent of a function."
1200+ },
1201+ {
1202+ "name": "hall",
1203+ "symbol": "",
1204+ "usage": "arvo",
1205+ "link": "/docs/glossary/hall/",
1206+ "desc": "The former messaging protocol for Arvo, no longer in use."
1207+ },
1208+ {
1209+ "name": "hd wallet",
1210+ "symbol": "",
1211+ "usage": "azimuth",
1212+ "link": "/docs/glossary/hdwallet",
1213+ "desc": "A system of related Ethereum addresses that store and manage an Urbit identity, each a proxy with different permissions over its management."
1214+ },
1215+ {
1216+ "name": "hoon",
1217+ "symbol": "",
1218+ "usage": "arvo",
1219+ "link": "/docs/glossary/hoon/",
1220+ "desc": "A strict, higher-order typed functional programming language that compiles to Nock."
1221+ },
1222+ {
1223+ "name": "invite tree",
1224+ "symbol": "",
1225+ "usage": "azimuth",
1226+ "link": "/docs/glossary/invitetree/",
1227+ "desc": "The state stored by the delegated sending contract, recording who gave a planet to whom under a specific star."
1228+ },
1229+ {
1230+ "name": "jacque",
1231+ "symbol": "",
1232+ "usage": "arvo",
1233+ "link": "/docs/glossary/jacque/",
1234+ "desc": "A Nock interpreter written in Java, in active development as a worker process for Vere."
1235+ },
1236+ {
1237+ "name": "keyfile",
1238+ "symbol": "",
1239+ "usage": "azimuth",
1240+ "link": "/docs/glossary/keyfile/",
1241+ "desc": "A piece of information used to associate a ship with an Urbit identity."
1242+ },
1243+ {
1244+ "name": "landscape",
1245+ "symbol": "",
1246+ "usage": "arvo",
1247+ "link": "/docs/glossary/landscape/",
1248+ "desc": "A front-end user interface for Urbit."
1249+ },
1250+ {
1251+ "name": "mark",
1252+ "symbol": "",
1253+ "usage": "arvo",
1254+ "link": "/docs/glossary/mark/",
1255+ "desc": "A file type in the Clay filesystem."
1256+ },
1257+ {
1258+ "name": "modulo",
1259+ "symbol": "",
1260+ "usage": "arvo",
1261+ "link": "/docs/glossary/modulo/",
1262+ "desc": "The name of the home screen interface for Urbit within Landscape."
1263+ },
1264+ {
1265+ "name": "moon",
1266+ "symbol": "",
1267+ "usage": "arvo",
1268+ "link": "/docs/glossary/moon/",
1269+ "desc": "A kind of ship on the Arvo network, issued by planets."
1270+ },
1271+ {
1272+ "name": "nock",
1273+ "symbol": "",
1274+ "usage": "hoon-nock",
1275+ "link": "/docs/glossary/nock/",
1276+ "desc": "A purely functional typeless programming language, and Urbit's lowest-level language."
1277+ },
1278+ {
1279+ "name": "noun",
1280+ "symbol": "",
1281+ "usage": "hoon-nock",
1282+ "link": "/docs/glossary/noun/",
1283+ "desc": "An atom or a cell. The basic data structure in Nock."
1284+ },
1285+ {
1286+ "name": "OTA",
1287+ "symbol": "",
1288+ "usage": "arvo",
1289+ "link": "/docs/glossary/ota-updates/",
1290+ "desc": "Ships have the ability to upgrade themselves over the air. They receive updates from a sponsor star or galaxy."
1291+ },
1292+ {
1293+ "name": "payload",
1294+ "symbol": "",
1295+ "usage": "payload",
1296+ "link": "/docs/glossary/payload/",
1297+ "desc": "The set of data needed to run computations in a core."
1298+ },
1299+ {
1300+ "name": "pH",
1301+ "symbol": "",
1302+ "usage": "arvo",
1303+ "link": "/docs/glossary/ph/",
1304+ "desc": "A Gall app that is a framework for fleet testing using Aqua."
1305+ },
1306+ {
1307+ "name": "pill",
1308+ "symbol": "",
1309+ "usage": "arvo",
1310+ "link": "/docs/glossary/pill/",
1311+ "desc": "A bootstrap sequence to launch an Urbit ship for the first time."
1312+ },
1313+ {
1314+ "name": "planet",
1315+ "symbol": "",
1316+ "usage": "arvo",
1317+ "link": "/docs/glossary/planet/",
1318+ "desc": "An Urbit identity at the bottom of the identity hierarchy. Issued by stars."
1319+ },
1320+ {
1321+ "name": "proxies",
1322+ "symbol": "",
1323+ "usage": "azimuth",
1324+ "link": "/docs/glossary/proxies/",
1325+ "desc": "Ethereum addresses in the Urbit HD Wallet that have limited powers."
1326+ },
1327+
1328+ {
1329+ "name": "replay",
1330+ "symbol": "",
1331+ "usage": "arvo",
1332+ "link": "/docs/glossary/replay/",
1333+ "desc": "How Vere computes the state of a ship's Arvo instance from an event log."
1334+ },
1335+ {
1336+ "name": "sail",
1337+ "symbol": "",
1338+ "usage": "arvo",
1339+ "link": "/docs/glossary/sailudon",
1340+ "desc": "A domain specific language for Hoon. Expresses XML data structures to render webpages."
1341+ },
1342+ {
1343+ "name": "trap",
1344+ "symbol": "",
1345+ "usage": "trap",
1346+ "link": "/docs/glossary/trap/",
1347+ "desc": "A core with one arm named $ and no sample."
1348+ },
1349+ {
1350+ "name": "udon",
1351+ "symbol": "",
1352+ "usage": "arvo",
1353+ "link": "/docs/glossary/sailudon",
1354+ "desc": "A domain specific language for Hoon. Similar to Markdown."
1355+ },
1356+ {
1357+ "name": "senate",
1358+ "symbol": "",
1359+ "usage": "azimuth",
1360+ "link": "/docs/glossary/senate/",
1361+ "desc": "The body of all galaxies that govern Azimuth by majority vote."
1362+ },
1363+ {
1364+ "name": "ship",
1365+ "symbol": "",
1366+ "usage": "arvo",
1367+ "link": "/docs/glossary/ship/",
1368+ "desc": "An instance of an Urbit computer that is a peer on the network."
1369+ },
1370+ {
1371+ "name": "arvo.network",
1372+ "symbol": "",
1373+ "usage": "arvo",
1374+ "link": "/docs/glossary/shiparvonetwork/",
1375+ "desc": "A way to connect to a ship via HTTP, using DNS lookup."
1376+ },
1377+ {
1378+ "name": "star",
1379+ "symbol": "",
1380+ "usage": "arvo",
1381+ "link": "/docs/glossary/star/",
1382+ "desc": "An Urbit identity sitting between stars and galaxies in the identity hierarchy. Infrastructural nodes for child planets."
1383+ },
1384+ {
1385+ "name": "sync",
1386+ "symbol": "",
1387+ "usage": "arvo",
1388+ "link": "/docs/glossary/sync/",
1389+ "desc": "<code>|sync</code> sets up synchronization between two Clay desks."
1390+ },
1391+ {
1392+ "name": "talk",
1393+ "symbol": "",
1394+ "usage": "arvo",
1395+ "link": "/docs/glossary/talk/",
1396+ "desc": "Urbit's first user application, sending messages between ships. No longer used, and replaced by Chat."
1397+ },
1398+ {
1399+ "name": "vane",
1400+ "symbol": "",
1401+ "usage": "arvo",
1402+ "link": "/docs/glossary/vane/",
1403+ "desc": "An Arvo kernel module that performs essential system operations."
1404+ },
1405+ {
1406+ "name": "vere",
1407+ "symbol": "",
1408+ "usage": "arvo",
1409+ "link": "/docs/glossary/vere/",
1410+ "desc": "The Nock runtime environment and Urbit virtual machine, running on Unix."
1411+ },
1412+ {
1413+ "name": "vote",
1414+ "symbol": "",
1415+ "usage": "azimuth",
1416+ "link": "/docs/glossary/voting/",
1417+ "desc": "Voting is a power available to galaxies in their capacities as members of the Galactic Senate."
1418+ },
1419+ {
1420+ "name": "wallet generator",
1421+ "symbol": "",
1422+ "usage": "azimuth",
1423+ "link": "/docs/glossary/wallet-generator/",
1424+ "desc": "Generates an Urbit HD wallet."
1425+ },
1426+ {
1427+ "name": "iris",
1428+ "symbol": "",
1429+ "usage": "arvo",
1430+ "link": "/docs/glossary/iris/",
1431+ "desc": "The server-side HTTP vane of Arvo. Its client-facing counterpart is Eyre."
1432+ },
1433+ {
1434+ "name": "jael",
1435+ "symbol": "",
1436+ "usage": "arvo",
1437+ "link": "/docs/glossary/jael/",
1438+ "desc": "Security and encryption vane of Arvo."
1439+ }, //standard library
1440+ {
1441+ "name": "Primitive parser engine",
1442+ "symbol": "ab",
1443+ "usage": "stdlib",
1444+ "link": "https://urbit.org/docs/reference/library/4j/#ab",
1445+ "desc": "Used in the Hoon standard library."
1446+ }, {
1447+ "name": "Absolute value",
1448+ "symbol": "abs:fl",
1449+ "usage": "stdlib",
1450+ "link": "https://urbit.org/docs/reference/library/3b/#abs-fl",
1451+ "desc": "Used in the Hoon standard library."
1452+ }, {
1453+ "name": "Absolute value (signed integer)",
1454+ "symbol": "abs:si",
1455+ "usage": "stdlib",
1456+ "link": "https://urbit.org/docs/reference/library/3a/#abs-si",
1457+ "desc": "Used in the Hoon standard library."
1458+ }, {
1459+ "name": "Compiler alias",
1460+ "symbol": "abel",
1461+ "usage": "stdlib",
1462+ "link": "https://urbit.org/docs/reference/library/4o/#abel",
1463+ "desc": "Used in the Hoon standard library."
1464+ }, {
1465+ "name": "Parse space",
1466+ "symbol": "ace",
1467+ "usage": "stdlib",
1468+ "link": "https://urbit.org/docs/reference/library/4h/#ace",
1469+ "desc": "Used in the Hoon standard library."
1470+ }, {
1471+ "name": "Add",
1472+ "symbol": "add",
1473+ "usage": "stdlib",
1474+ "link": "https://urbit.org/docs/reference/library/1a/#add",
1475+ "desc": "Used in the Hoon standard library."
1476+ }, {
1477+ "name": "Add (floating point)",
1478+ "symbol": "add:ff",
1479+ "usage": "stdlib",
1480+ "link": "https://urbit.org/docs/reference/library/3b/#add-ff",
1481+ "desc": "Used in the Hoon standard library."
1482+ }, {
1483+ "name": "Add (with exact/rounded flag)",
1484+ "symbol": "add:fl",
1485+ "usage": "stdlib",
1486+ "link": "https://urbit.org/docs/reference/library/3b/#add-fl",
1487+ "desc": "Used in the Hoon standard library."
1488+ }, {
1489+ "name": "Prepend to list",
1490+ "symbol": "add:ja",
1491+ "usage": "stdlib",
1492+ "link": "https://urbit.org/docs/reference/library/2j/#add-ja",
1493+ "desc": "Used in the Hoon standard library."
1494+ }, {
1495+ "name": "Add (double-precision float)",
1496+ "symbol": "add:rd",
1497+ "usage": "stdlib",
1498+ "link": "https://urbit.org/docs/reference/library/3b/#add-rd",
1499+ "desc": "Used in the Hoon standard library."
1500+ }, {
1501+ "name": "Add (half-precision float)",
1502+ "symbol": "add:rh",
1503+ "usage": "stdlib",
1504+ "link": "https://urbit.org/docs/reference/library/3b/#add-rh",
1505+ "desc": "Used in the Hoon standard library."
1506+ }, {
1507+ "name": "Add (single-precision float)",
1508+ "symbol": "add:rs",
1509+ "usage": "stdlib",
1510+ "link": "https://urbit.org/docs/reference/library/3b/#add-rs",
1511+ "desc": "Used in the Hoon standard library."
1512+ }, {
1513+ "name": "Add (quad-precision float)",
1514+ "symbol": "add:rq",
1515+ "usage": "stdlib",
1516+ "link": "https://urbit.org/docs/reference/library/3b/#add-rq",
1517+ "desc": "Used in the Hoon standard library."
1518+ }, {
1519+ "name": "Top-level atom parser engine",
1520+ "symbol": "ag",
1521+ "usage": "stdlib",
1522+ "link": "https://urbit.org/docs/reference/library/4j/#ag",
1523+ "desc": "Used in the Hoon standard library."
1524+ }, {
1525+ "name": "Parse alphabetic characters",
1526+ "symbol": "alf",
1527+ "usage": "stdlib",
1528+ "link": "https://urbit.org/docs/reference/library/4i/#alf",
1529+ "desc": "Used in the Hoon standard library."
1530+ }, {
1531+ "name": "Logical AND (map and wet gate)",
1532+ "symbol": "all:by",
1533+ "usage": "stdlib",
1534+ "link": "https://urbit.org/docs/reference/library/2i/#all-by",
1535+ "desc": "Used in the Hoon standard library."
1536+ }, {
1537+ "name": "Logical AND (set and wet gate)",
1538+ "symbol": "all:in",
1539+ "usage": "stdlib",
1540+ "link": "https://urbit.org/docs/reference/library/2h/#all-in",
1541+ "desc": "Used in the Hoon standard library."
1542+ }, {
1543+ "name": "Parse alphanumeric characters",
1544+ "symbol": "aln",
1545+ "usage": "stdlib",
1546+ "link": "https://urbit.org/docs/reference/library/4i/#aln",
1547+ "desc": "Used in the Hoon standard library."
1548+ }, {
1549+ "name": "Parse alphanumeric characters and -",
1550+ "symbol": "alp",
1551+ "usage": "stdlib",
1552+ "link": "https://urbit.org/docs/reference/library/4i/#alp",
1553+ "desc": "Used in the Hoon standard library."
1554+ }, {
1555+ "name": "Logical OR (map and wet gate)",
1556+ "symbol": "any:by",
1557+ "usage": "stdlib",
1558+ "link": "https://urbit.org/docs/reference/library/2i/#any-by",
1559+ "desc": "Used in the Hoon standard library."
1560+ }, {
1561+ "name": "Logical OR (set and gate)",
1562+ "symbol": "any:in",
1563+ "usage": "stdlib",
1564+ "link": "https://urbit.org/docs/reference/library/2h/#any-in",
1565+ "desc": "Used in the Hoon standard library."
1566+ }, {
1567+ "name": "Alphabetical order",
1568+ "symbol": "aor",
1569+ "usage": "stdlib",
1570+ "link": "https://urbit.org/docs/reference/library/2f/#aor",
1571+ "desc": "Used in the Hoon standard library."
1572+ }, {
1573+ "name": "Parse 0 or rule",
1574+ "symbol": "ape:ag",
1575+ "usage": "stdlib",
1576+ "link": "https://urbit.org/docs/reference/library/4j/#ape-ag",
1577+ "desc": "Used in the Hoon standard library."
1578+ }, {
1579+ "name": "Check correctness (map)",
1580+ "symbol": "apt:by",
1581+ "usage": "stdlib",
1582+ "link": "https://urbit.org/docs/reference/library/2i/#apt-by",
1583+ "desc": "Used in the Hoon standard library."
1584+ }, {
1585+ "name": "Check correctness (set)",
1586+ "symbol": "apt:in",
1587+ "usage": "stdlib",
1588+ "link": "https://urbit.org/docs/reference/library/2h/#apt-in",
1589+ "desc": "Used in the Hoon standard library."
1590+ }, {
1591+ "name": "(Undocumented)",
1592+ "symbol": "at",
1593+ "usage": "stdlib",
1594+ "link": "https://urbit.org/docs/reference/library/4b/#at",
1595+ "desc": "Used in the Hoon standard library."
1596+ }, {
1597+ "name": "'Type' of atom",
1598+ "symbol": "aura",
1599+ "usage": "stdlib",
1600+ "link": "https://urbit.org/docs/reference/library/4o/#aura",
1601+ "desc": "Used in the Hoon standard library."
1602+ }, {
1603+ "name": "Nock axis",
1604+ "symbol": "axis",
1605+ "usage": "stdlib",
1606+ "link": "https://urbit.org/docs/reference/library/4o/#axis",
1607+ "desc": "Used in the Hoon standard library."
1608+ }, {
1609+ "name": "Balance queue",
1610+ "symbol": "bal:to",
1611+ "usage": "stdlib",
1612+ "link": "https://urbit.org/docs/reference/library/2k/#bal-to",
1613+ "desc": "Used in the Hoon standard library."
1614+ }, {
1615+ "name": "Parse | (bar)",
1616+ "symbol": "bar",
1617+ "usage": "stdlib",
1618+ "link": "https://urbit.org/docs/reference/library/4h/#bar",
1619+ "desc": "Used in the Hoon standard library."
1620+ }, {
1621+ "name": "Parse \\ (bas)",
1622+ "symbol": "bas",
1623+ "usage": "stdlib",
1624+ "link": "https://urbit.org/docs/reference/library/4h/#bas",
1625+ "desc": "Used in the Hoon standard library."
1626+ }, {
1627+ "name": "Base type",
1628+ "symbol": "base",
1629+ "usage": "stdlib",
1630+ "link": "https://urbit.org/docs/reference/library/4o/#base",
1631+ "desc": "Used in the Hoon standard library."
1632+ }, {
1633+ "name": "Parser modifier (LSB-ordered list as atom of base)",
1634+ "symbol": "bass",
1635+ "usage": "stdlib",
1636+ "link": "https://urbit.org/docs/reference/library/4f/#bass",
1637+ "desc": "Used in the Hoon standard library."
1638+ }, {
1639+ "name": "Parses binary number",
1640+ "symbol": "bay:ag",
1641+ "usage": "stdlib",
1642+ "link": "https://urbit.org/docs/reference/library/4j/#bay-ag",
1643+ "desc": "Used in the Hoon standard library."
1644+ }, {
1645+ "name": "Boolean",
1646+ "symbol": "bean",
1647+ "usage": "stdlib",
1648+ "link": "https://urbit.org/docs/reference/library/4o/#bean",
1649+ "desc": "Used in the Hoon standard library."
1650+ }, {
1651+ "name": "Tape builder",
1652+ "symbol": "beer",
1653+ "usage": "stdlib",
1654+ "link": "https://urbit.org/docs/reference/library/4o/#beer",
1655+ "desc": "Used in the Hoon standard library."
1656+ }, {
1657+ "name": "XML interpolation cases",
1658+ "symbol": "beet",
1659+ "usage": "stdlib",
1660+ "link": "https://urbit.org/docs/reference/library/4o/#beet",
1661+ "desc": "Used in the Hoon standard library."
1662+ }, {
1663+ "name": "Conditional composer",
1664+ "symbol": "bend",
1665+ "usage": "stdlib",
1666+ "link": "https://urbit.org/docs/reference/library/4e/#bend",
1667+ "desc": "Used in the Hoon standard library."
1668+ }, {
1669+ "name": "Parse hep and lus axis syntax",
1670+ "symbol": "bet",
1671+ "usage": "stdlib",
1672+ "link": "https://urbit.org/docs/reference/library/4i/#bet",
1673+ "desc": "Used in the Hoon standard library."
1674+ }, {
1675+ "name": "Binary exponent",
1676+ "symbol": "bex",
1677+ "usage": "stdlib",
1678+ "link": "https://urbit.org/docs/reference/library/2c/#bex",
1679+ "desc": "Used in the Hoon standard library."
1680+ }, {
1681+ "name": "Converts from fn to @r",
1682+ "symbol": "bif:ff",
1683+ "usage": "stdlib",
1684+ "link": "https://urbit.org/docs/reference/library/3b/#bif-ff",
1685+ "desc": "Used in the Hoon standard library."
1686+ }, {
1687+ "name": "Bifurcate map",
1688+ "symbol": "bif:by",
1689+ "usage": "stdlib",
1690+ "link": "https://urbit.org/docs/reference/library/2i/#bif-by",
1691+ "desc": "Used in the Hoon standard library."
1692+ }, {
1693+ "name": "Bifurcate set",
1694+ "symbol": "bif:in",
1695+ "usage": "stdlib",
1696+ "link": "https://urbit.org/docs/reference/library/2h/#bif-in",
1697+ "desc": "Used in the Hoon standard library."
1698+ }, {
1699+ "name": "Unit as argument",
1700+ "symbol": "biff",
1701+ "usage": "stdlib",
1702+ "link": "https://urbit.org/docs/reference/library/2a/#biff",
1703+ "desc": "Used in the Hoon standard library."
1704+ }, {
1705+ "name": "Binary to atom",
1706+ "symbol": "bin",
1707+ "usage": "stdlib",
1708+ "link": "https://urbit.org/docs/reference/library/4i/#bin",
1709+ "desc": "Used in the Hoon standard library."
1710+ }, {
1711+ "name": "Non-unit function to unit, producing unit",
1712+ "symbol": "bind",
1713+ "usage": "stdlib",
1714+ "link": "https://urbit.org/docs/reference/library/2a/#bind",
1715+ "desc": "Used in the Hoon standard library."
1716+ }, {
1717+ "name": "Parse IPv6",
1718+ "symbol": "bip:ag",
1719+ "usage": "stdlib",
1720+ "link": "https://urbit.org/docs/reference/library/4j/#bip-ag",
1721+ "desc": "Used in the Hoon standard library."
1722+ }, {
1723+ "name": "fn to @r with rounding",
1724+ "symbol": "bit:ff",
1725+ "usage": "stdlib",
1726+ "link": "https://urbit.org/docs/reference/library/3b/#bit-ff",
1727+ "desc": "Used in the Hoon standard library."
1728+ }, {
1729+ "name": "fn to double-precision binary float",
1730+ "symbol": "bit:rd",
1731+ "usage": "stdlib",
1732+ "link": "https://urbit.org/docs/reference/library/3b/#bit-rd",
1733+ "desc": "Used in the Hoon standard library."
1734+ }, {
1735+ "name": "fn to half-precision float",
1736+ "symbol": "bit:rh",
1737+ "usage": "stdlib",
1738+ "link": "https://urbit.org/docs/reference/library/3b/#bit-rh",
1739+ "desc": "Used in the Hoon standard library."
1740+ }, {
1741+ "name": "fn to single-precision float",
1742+ "symbol": "bit:rs",
1743+ "usage": "stdlib",
1744+ "link": "https://urbit.org/docs/reference/library/3b/#bit-rs",
1745+ "desc": "Used in the Hoon standard library."
1746+ }, {
1747+ "name": "fn to quad-precision float",
1748+ "symbol": "bit:rq",
1749+ "usage": "stdlib",
1750+ "link": "https://urbit.org/docs/reference/library/3b/#bit-rq",
1751+ "desc": "Used in the Hoon standard library."
1752+ }, {
1753+ "name": "Parse hex pair",
1754+ "symbol": "bix:ab",
1755+ "usage": "stdlib",
1756+ "link": "https://urbit.org/docs/reference/library/4j/#bix-ab",
1757+ "desc": "Used in the Hoon standard library."
1758+ }, {
1759+ "name": "Parse odor-atom pair",
1760+ "symbol": "bisk:so",
1761+ "usage": "stdlib",
1762+ "link": "https://urbit.org/docs/reference/library/4l/#bisk-so",
1763+ "desc": "Used in the Hoon standard library."
1764+ }, {
1765+ "name": "Blocksize",
1766+ "symbol": "bloq",
1767+ "usage": "stdlib",
1768+ "link": "https://urbit.org/docs/reference/library/1c/#bloq",
1769+ "desc": "Used in the Hoon standard library."
1770+ }, {
1771+ "name": "Replace null",
1772+ "symbol": "bond",
1773+ "usage": "stdlib",
1774+ "link": "https://urbit.org/docs/reference/library/2a/#bond",
1775+ "desc": "Used in the Hoon standard library."
1776+ }, {
1777+ "name": "Parser modifier: LSB",
1778+ "symbol": "boss",
1779+ "usage": "stdlib",
1780+ "link": "https://urbit.org/docs/reference/library/4f/#boss",
1781+ "desc": "Used in the Hoon standard library."
1782+ }, {
1783+ "name": "Group unit values into pair",
1784+ "symbol": "both",
1785+ "usage": "stdlib",
1786+ "link": "https://urbit.org/docs/reference/library/2a/#both",
1787+ "desc": "Used in the Hoon standard library."
1788+ }, {
1789+ "name": "Parse $ (buc)",
1790+ "symbol": "buc",
1791+ "usage": "stdlib",
1792+ "link": "https://urbit.org/docs/reference/library/4h/#buc",
1793+ "desc": "Used in the Hoon standard library."
1794+ }, {
1795+ "name": "Parse binary digit",
1796+ "symbol": "but",
1797+ "usage": "stdlib",
1798+ "link": "https://urbit.org/docs/reference/library/4i/#but",
1799+ "desc": "Used in the Hoon standard library."
1800+ }, {
1801+ "name": "Parse _ (cab)",
1802+ "symbol": "cab",
1803+ "usage": "stdlib",
1804+ "link": "https://urbit.org/docs/reference/library/4h/#cab",
1805+ "desc": "Used in the Hoon standard library."
1806+ }, {
1807+ "name": "Assemble",
1808+ "symbol": "can",
1809+ "usage": "stdlib",
1810+ "link": "https://urbit.org/docs/reference/library/2c/#can",
1811+ "desc": "Used in the Hoon standard library."
1812+ }, {
1813+ "name": "Tree head",
1814+ "symbol": "cap",
1815+ "usage": "stdlib",
1816+ "link": "https://urbit.org/docs/reference/library/1b/#cap",
1817+ "desc": "Used in the Hoon standard library."
1818+ }, {
1819+ "name": "To lowercase",
1820+ "symbol": "cass",
1821+ "usage": "stdlib",
1822+ "link": "https://urbit.org/docs/reference/library/4b/#cass",
1823+ "desc": "Used in the Hoon standard library."
1824+ }, {
1825+ "name": "Concatenate",
1826+ "symbol": "cat",
1827+ "usage": "stdlib",
1828+ "link": "https://urbit.org/docs/reference/library/2c/#cat",
1829+ "desc": "Used in the Hoon standard library."
1830+ }, {
1831+ "name": "Parse % (cen)",
1832+ "symbol": "cen",
1833+ "usage": "stdlib",
1834+ "link": "https://urbit.org/docs/reference/library/4h/#cen",
1835+ "desc": "Used in the Hoon standard library."
1836+ }, {
1837+ "name": "Days in a century",
1838+ "symbol": "cet:yo",
1839+ "usage": "stdlib",
1840+ "link": "https://urbit.org/docs/reference/library/3c/#cet-yo",
1841+ "desc": "Used in the Hoon standard library."
1842+ }, {
1843+ "name": "Character",
1844+ "symbol": "char",
1845+ "usage": "stdlib",
1846+ "link": "https://urbit.org/docs/reference/library/2q/#char",
1847+ "desc": "Used in the Hoon standard library."
1848+ }, {
1849+ "name": "Jet hint information",
1850+ "symbol": "chum",
1851+ "usage": "stdlib",
1852+ "link": "https://urbit.org/docs/reference/library/4o/#chum",
1853+ "desc": "Used in the Hoon standard library."
1854+ }, {
1855+ "name": "Octal digit",
1856+ "symbol": "cit",
1857+ "usage": "stdlib",
1858+ "link": "https://urbit.org/docs/reference/library/4i/#cit",
1859+ "desc": "Used in the Hoon standard library."
1860+ }, {
1861+ "name": "Apply function to two units",
1862+ "symbol": "clap",
1863+ "usage": "stdlib",
1864+ "link": "https://urbit.org/docs/reference/library/2a/#clap",
1865+ "desc": "Used in the Hoon standard library."
1866+ }, {
1867+ "name": "Compare (signed integer)",
1868+ "symbol": "cmp:si",
1869+ "usage": "stdlib",
1870+ "link": "https://urbit.org/docs/reference/library/3a/#cmp-si",
1871+ "desc": "Used in the Hoon standard library."
1872+ }, {
1873+ "name": "Literal rendering engine",
1874+ "symbol": "co",
1875+ "usage": "stdlib",
1876+ "link": "https://urbit.org/docs/reference/library/4k/#co",
1877+ "desc": "Used in the Hoon standard library."
1878+ }, {
1879+ "name": "Tuple of core information",
1880+ "symbol": "coil",
1881+ "usage": "stdlib",
1882+ "link": "https://urbit.org/docs/reference/library/4o/#coil",
1883+ "desc": "Used in the Hoon standard library."
1884+ }, {
1885+ "name": "Noun-literal syntax cases",
1886+ "symbol": "coin",
1887+ "usage": "stdlib",
1888+ "link": "https://urbit.org/docs/reference/library/3g/#coin",
1889+ "desc": "Used in the Hoon standard library."
1890+ }, {
1891+ "name": "Parse : (col)",
1892+ "symbol": "col",
1893+ "usage": "stdlib",
1894+ "link": "https://urbit.org/docs/reference/library/4h/#col",
1895+ "desc": "Used in the Hoon standard library."
1896+ }, {
1897+ "name": "Replace with constant",
1898+ "symbol": "cold",
1899+ "usage": "stdlib",
1900+ "link": "https://urbit.org/docs/reference/library/4f/#cold",
1901+ "desc": "Used in the Hoon standard library."
1902+ }, {
1903+ "name": "Parse , (com)",
1904+ "symbol": "com",
1905+ "usage": "stdlib",
1906+ "link": "https://urbit.org/docs/reference/library/4h/#com",
1907+ "desc": "Used in the Hoon standard library."
1908+ }, {
1909+ "name": "Arbitrary compose",
1910+ "symbol": "comp",
1911+ "usage": "stdlib",
1912+ "link": "https://urbit.org/docs/reference/library/4e/#comp",
1913+ "desc": "Used in the Hoon standard library."
1914+ }, {
1915+ "name": "Binary OR",
1916+ "symbol": "con",
1917+ "usage": "stdlib",
1918+ "link": "https://urbit.org/docs/reference/library/2d/#con",
1919+ "desc": "Used in the Hoon standard library."
1920+ }, {
1921+ "name": "Apply gate",
1922+ "symbol": "cook",
1923+ "usage": "stdlib",
1924+ "link": "https://urbit.org/docs/reference/library/4f/#cook",
1925+ "desc": "Used in the Hoon standard library."
1926+ }, {
1927+ "name": "UTF-8 text",
1928+ "symbol": "cord",
1929+ "usage": "stdlib",
1930+ "link": "https://urbit.org/docs/reference/library/2q/#cord",
1931+ "desc": "Used in the Hoon standard library."
1932+ }, {
1933+ "name": "Compose forward",
1934+ "symbol": "cork",
1935+ "usage": "stdlib",
1936+ "link": "https://urbit.org/docs/reference/library/2n/#cork",
1937+ "desc": "Used in the Hoon standard library."
1938+ }, {
1939+ "name": "Compose backward",
1940+ "symbol": "corl",
1941+ "usage": "stdlib",
1942+ "link": "https://urbit.org/docs/reference/library/2n/#corl",
1943+ "desc": "Used in the Hoon standard library."
1944+ }, {
1945+ "name": "Tape to cord",
1946+ "symbol": "crip",
1947+ "usage": "stdlib",
1948+ "link": "https://urbit.org/docs/reference/library/4b/#crip",
1949+ "desc": "Used in the Hoon standard library."
1950+ }, {
1951+ "name": "Parse @da, @dr, @p, @t",
1952+ "symbol": "crub:so",
1953+ "usage": "stdlib",
1954+ "link": "https://urbit.org/docs/reference/library/4l/#crub-so",
1955+ "desc": "Used in the Hoon standard library."
1956+ }, {
1957+ "name": "Unpack atom to noun",
1958+ "symbol": "cue",
1959+ "usage": "stdlib",
1960+ "link": "https://urbit.org/docs/reference/library/2p/#cue",
1961+ "desc": "Used in the Hoon standard library."
1962+ }, {
1963+ "name": "Right-curry a gate",
1964+ "symbol": "curr",
1965+ "usage": "stdlib",
1966+ "link": "https://urbit.org/docs/reference/library/2n/#curr",
1967+ "desc": "Used in the Hoon standard library."
1968+ }, {
1969+ "name": "Curry left a gate",
1970+ "symbol": "cury",
1971+ "usage": "stdlib",
1972+ "link": "https://urbit.org/docs/reference/library/2n/#cury",
1973+ "desc": "Used in the Hoon standard library."
1974+ }, {
1975+ "name": "To uppercase",
1976+ "symbol": "cuss",
1977+ "usage": "stdlib",
1978+ "link": "https://urbit.org/docs/reference/library/4b/#cuss",
1979+ "desc": "Used in the Hoon standard library."
1980+ }, {
1981+ "name": "Slice",
1982+ "symbol": "cut",
1983+ "usage": "stdlib",
1984+ "link": "https://urbit.org/docs/reference/library/2c/#cut",
1985+ "desc": "Used in the Hoon standard library."
1986+ }, {
1987+ "name": "Render decimal",
1988+ "symbol": "d:ne",
1989+ "usage": "stdlib",
1990+ "link": "https://urbit.org/docs/reference/library/4j/#d-ne",
1991+ "desc": "Used in the Hoon standard library."
1992+ }, {
1993+ "name": "Point in time",
1994+ "symbol": "date",
1995+ "usage": "stdlib",
1996+ "link": "https://urbit.org/docs/reference/library/2q/#date",
1997+ "desc": "Used in the Hoon standard library."
1998+ }, {
1999+ "name": "Seconds in day",
2000+ "symbol": "day:yo",
2001+ "usage": "stdlib",
2002+ "link": "https://urbit.org/docs/reference/library/3c/#day-yo",
2003+ "desc": "Used in the Hoon standard library."
2004+ }, {
2005+ "name": "Decrement",
2006+ "symbol": "dec",
2007+ "usage": "stdlib",
2008+ "link": "https://urbit.org/docs/reference/library/1a/#dec",
2009+ "desc": "Used in the Hoon standard library."
2010+ }, {
2011+ "name": "Difference (map)",
2012+ "symbol": "def:by",
2013+ "usage": "stdlib",
2014+ "link": "https://urbit.org/docs/reference/library/2i/#def-by",
2015+ "desc": "Used in the Hoon standard library."
2016+ }, {
2017+ "name": "Delete (map)",
2018+ "symbol": "del:by",
2019+ "usage": "stdlib",
2020+ "link": "https://urbit.org/docs/reference/library/2i/#del-by",
2021+ "desc": "Used in the Hoon standard library."
2022+ }, {
2023+ "name": "Delete (set)",
2024+ "symbol": "del:in",
2025+ "usage": "stdlib",
2026+ "link": "https://urbit.org/docs/reference/library/2h/#del-in",
2027+ "desc": "Used in the Hoon standard library."
2028+ }, {
2029+ "name": "Delete (jug)",
2030+ "symbol": "del:ju",
2031+ "usage": "stdlib",
2032+ "link": "https://urbit.org/docs/reference/library/2j/#del-ju",
2033+ "desc": "Used in the Hoon standard library."
2034+ }, {
2035+ "name": "Decimal to atom",
2036+ "symbol": "dem",
2037+ "usage": "stdlib",
2038+ "link": "https://urbit.org/docs/reference/library/4i/#dem",
2039+ "desc": "Used in the Hoon standard library."
2040+ }, {
2041+ "name": "Parse decmal with dots",
2042+ "symbol": "dem:ag",
2043+ "usage": "stdlib",
2044+ "link": "https://urbit.org/docs/reference/library/4j/#dem-ag",
2045+ "desc": "Used in the Hoon standard library."
2046+ }, {
2047+ "name": "Denormalizes (floating point)",
2048+ "symbol": "den:fl",
2049+ "usage": "stdlib",
2050+ "link": "https://urbit.org/docs/reference/library/3b/#den-fl",
2051+ "desc": "Used in the Hoon standard library."
2052+ }, {
2053+ "name": "Difference as patch (map)",
2054+ "symbol": "dep:by",
2055+ "usage": "stdlib",
2056+ "link": "https://urbit.org/docs/reference/library/2i/#dep-by",
2057+ "desc": "Used in the Hoon standard library."
2058+ }, {
2059+ "name": "Maximum depth (queue)",
2060+ "symbol": "dep:to",
2061+ "usage": "stdlib",
2062+ "link": "https://urbit.org/docs/reference/library/2k/#dep-to",
2063+ "desc": "Used in the Hoon standard library."
2064+ }, {
2065+ "name": "Difference between atoms (modular basis)",
2066+ "symbol": "dif:fe",
2067+ "usage": "stdlib",
2068+ "link": "https://urbit.org/docs/reference/library/2c/#dif-fe",
2069+ "desc": "Used in the Hoon standard library."
2070+ }, {
2071+ "name": "Subtraction (modular base)",
2072+ "symbol": "dif:fo",
2073+ "usage": "stdlib",
2074+ "link": "https://urbit.org/docs/reference/library/3a/#dif-fo",
2075+ "desc": "Used in the Hoon standard library."
2076+ }, {
2077+ "name": "Difference (set)",
2078+ "symbol": "dif:in",
2079+ "usage": "stdlib",
2080+ "link": "https://urbit.org/docs/reference/library/2h/#dif-in",
2081+ "desc": "Used in the Hoon standard library."
2082+ }, {
2083+ "name": "Subtraction (signed integer)",
2084+ "symbol": "dif:si",
2085+ "usage": "stdlib",
2086+ "link": "https://urbit.org/docs/reference/library/3a/#dif-si",
2087+ "desc": "Used in the Hoon standard library."
2088+ }, {
2089+ "name": "Address of key (map)",
2090+ "symbol": "dig:by",
2091+ "usage": "stdlib",
2092+ "link": "https://urbit.org/docs/reference/library/2i/#dig-by",
2093+ "desc": "Used in the Hoon standard library."
2094+ }, {
2095+ "name": "Address of a in set",
2096+ "symbol": "dig:in",
2097+ "usage": "stdlib",
2098+ "link": "https://urbit.org/docs/reference/library/2h/#dig-in",
2099+ "desc": "Used in the Hoon standard library."
2100+ }, {
2101+ "name": "Parse decimal number",
2102+ "symbol": "dim:ag",
2103+ "usage": "stdlib",
2104+ "link": "https://urbit.org/docs/reference/library/4j/#dim-ag",
2105+ "desc": "Used in the Hoon standard library."
2106+ }, {
2107+ "name": "Aura-atom pair",
2108+ "symbol": "dime",
2109+ "usage": "stdlib",
2110+ "link": "https://urbit.org/docs/reference/library/3g/#dime",
2111+ "desc": "Used in the Hoon standard library."
2112+ }, {
2113+ "name": "(Undocumented)",
2114+ "symbol": "din:re",
2115+ "usage": "stdlib",
2116+ "link": "https://urbit.org/docs/reference/library/4c/#din-re",
2117+ "desc": "Used in the Hoon standard library."
2118+ }, {
2119+ "name": "Binary AND (atoms)",
2120+ "symbol": "dis",
2121+ "usage": "stdlib",
2122+ "link": "https://urbit.org/docs/reference/library/2d/#dis",
2123+ "desc": "Used in the Hoon standard library."
2124+ }, {
2125+ "name": "Decimal digit",
2126+ "symbol": "dit",
2127+ "usage": "stdlib",
2128+ "link": "https://urbit.org/docs/reference/library/4i/#dit",
2129+ "desc": "Used in the Hoon standard library."
2130+ }, {
2131+ "name": "Divide",
2132+ "symbol": "div",
2133+ "usage": "stdlib",
2134+ "link": "https://urbit.org/docs/reference/library/1a/#div",
2135+ "desc": "Used in the Hoon standard library."
2136+ }, {
2137+ "name": "Divide (IEEE float)",
2138+ "symbol": "div:ff",
2139+ "usage": "stdlib",
2140+ "link": "https://urbit.org/docs/reference/library/3b/#div-ff",
2141+ "desc": "Used in the Hoon standard library."
2142+ }, {
2143+ "name": "Divide (signed and unsigned integer cell)",
2144+ "symbol": "div:fl",
2145+ "usage": "stdlib",
2146+ "link": "https://urbit.org/docs/reference/library/3b/#div-fl",
2147+ "desc": "Used in the Hoon standard library."
2148+ }, {
2149+ "name": "Double precision float",
2150+ "symbol": "div:rd",
2151+ "usage": "stdlib",
2152+ "link": "https://urbit.org/docs/reference/library/3b/#div-rd",
2153+ "desc": "Used in the Hoon standard library."
2154+ }, {
2155+ "name": "Divide (half-precision float)",
2156+ "symbol": "div:rh",
2157+ "usage": "stdlib",
2158+ "link": "https://urbit.org/docs/reference/library/3b/#div-rh",
2159+ "desc": "Used in the Hoon standard library."
2160+ }, {
2161+ "name": "Divide (single-precision float)",
2162+ "symbol": "div:rs",
2163+ "usage": "stdlib",
2164+ "link": "https://urbit.org/docs/reference/library/3b/#div-rs",
2165+ "desc": "Used in the Hoon standard library."
2166+ }, {
2167+ "name": "Divide (quad-precision float)",
2168+ "symbol": "div:rq",
2169+ "usage": "stdlib",
2170+ "link": "https://urbit.org/docs/reference/library/3b/#div-rq",
2171+ "desc": "Used in the Hoon standard library."
2172+ }, {
2173+ "name": "Optional gap",
2174+ "symbol": "dog",
2175+ "usage": "stdlib",
2176+ "link": "https://urbit.org/docs/reference/library/4i/#dog",
2177+ "desc": "Used in the Hoon standard library."
2178+ }, {
2179+ "name": "@p separator",
2180+ "symbol": "doh",
2181+ "usage": "stdlib",
2182+ "link": "https://urbit.org/docs/reference/library/4i/#doh",
2183+ "desc": "Used in the Hoon standard library."
2184+ }, {
2185+ "name": "Parse double quote",
2186+ "symbol": "doq",
2187+ "usage": "stdlib",
2188+ "link": "https://urbit.org/docs/reference/library/4h/#doq",
2189+ "desc": "Used in the Hoon standard library."
2190+ }, {
2191+ "name": "Numeric order",
2192+ "symbol": "dor",
2193+ "usage": "stdlib",
2194+ "link": "https://urbit.org/docs/reference/library/2f/#dor",
2195+ "desc": "Used in the Hoon standard library."
2196+ }, {
2197+ "name": "Parse period",
2198+ "symbol": "dot",
2199+ "usage": "stdlib",
2200+ "link": "https://urbit.org/docs/reference/library/4h/#dot",
2201+ "desc": "Used in the Hoon standard library."
2202+ }, {
2203+ "name": "@r to decimal float",
2204+ "symbol": "drg:ff",
2205+ "usage": "stdlib",
2206+ "link": "https://urbit.org/docs/reference/library/3b/#drg-ff",
2207+ "desc": "Used in the Hoon standard library."
2208+ }, {
2209+ "name": "Get printable decimal (signed and unsigned integer cell)",
2210+ "symbol": "drg:fl",
2211+ "usage": "stdlib",
2212+ "link": "https://urbit.org/docs/reference/library/3b/#drg-fl",
2213+ "desc": "Used in the Hoon standard library."
2214+ }, {
2215+ "name": "@rd to decimal float",
2216+ "symbol": "drg:rd",
2217+ "usage": "stdlib",
2218+ "link": "https://urbit.org/docs/reference/library/3b/#drg-rd",
2219+ "desc": "Used in the Hoon standard library."
2220+ }, {
2221+ "name": "@rh to decimal float",
2222+ "symbol": "drg:rh",
2223+ "usage": "stdlib",
2224+ "link": "https://urbit.org/docs/reference/library/3b/#drg-rh",
2225+ "desc": "Used in the Hoon standard library."
2226+ }, {
2227+ "name": "@rs to decimal float",
2228+ "symbol": "drg:rs",
2229+ "usage": "stdlib",
2230+ "link": "https://urbit.org/docs/reference/library/3b/#drg-rs",
2231+ "desc": "Used in the Hoon standard library."
2232+ }, {
2233+ "name": "@rq to decimal float",
2234+ "symbol": "drg:rq",
2235+ "usage": "stdlib",
2236+ "link": "https://urbit.org/docs/reference/library/3b/#drg-rq",
2237+ "desc": "Used in the Hoon standard library."
2238+ }, {
2239+ "name": "Unit to list",
2240+ "symbol": "drop",
2241+ "usage": "stdlib",
2242+ "link": "https://urbit.org/docs/reference/library/2a/#drop",
2243+ "desc": "Used in the Hoon standard library."
2244+ }, {
2245+ "name": "Modulus (signed integer)",
2246+ "symbol": "dul:si",
2247+ "usage": "stdlib",
2248+ "link": "https://urbit.org/docs/reference/library/3a/#dul-si",
2249+ "desc": "Used in the Hoon standard library."
2250+ }, {
2251+ "name": "Parse decimal with leading zero",
2252+ "symbol": "dum:ag",
2253+ "usage": "stdlib",
2254+ "link": "https://urbit.org/docs/reference/library/4j/#dum-ag",
2255+ "desc": "Used in the Hoon standard library."
2256+ }, {
2257+ "name": "-- to ~",
2258+ "symbol": "dun",
2259+ "usage": "stdlib",
2260+ "link": "https://urbit.org/docs/reference/library/4i/#dun",
2261+ "desc": "Used in the Hoon standard library."
2262+ }, {
2263+ "name": "== to ~",
2264+ "symbol": "duz",
2265+ "usage": "stdlib",
2266+ "link": "https://urbit.org/docs/reference/library/4i/#duz",
2267+ "desc": "Used in the Hoon standard library."
2268+ }, {
2269+ "name": "Divide (with remainder)",
2270+ "symbol": "dvr",
2271+ "usage": "stdlib",
2272+ "link": "https://urbit.org/docs/reference/library/1a/#dvr",
2273+ "desc": "Used in the Hoon standard library."
2274+ }, {
2275+ "name": "Exact add",
2276+ "symbol": "ead:fl",
2277+ "usage": "stdlib",
2278+ "link": "https://urbit.org/docs/reference/library/3b/#ead-fl",
2279+ "desc": "Used in the Hoon standard library."
2280+ }, {
2281+ "name": "Mold of fork between two types",
2282+ "symbol": "each",
2283+ "usage": "stdlib",
2284+ "link": "https://urbit.org/docs/reference/library/1c/#each",
2285+ "desc": "Used in the Hoon standard library."
2286+ }, {
2287+ "name": "Always parse",
2288+ "symbol": "easy",
2289+ "usage": "stdlib",
2290+ "link": "https://urbit.org/docs/reference/library/4f/#easy",
2291+ "desc": "Used in the Hoon standard library."
2292+ }, {
2293+ "name": "Parsing location metadata",
2294+ "symbol": "edge",
2295+ "usage": "stdlib",
2296+ "link": "https://urbit.org/docs/reference/library/3g/#edge",
2297+ "desc": "Used in the Hoon standard library."
2298+ }, {
2299+ "name": "Extended Euclidean algorithm",
2300+ "symbol": "egcd",
2301+ "usage": "stdlib",
2302+ "link": "https://urbit.org/docs/reference/library/3a/#egcd",
2303+ "desc": "Used in the Hoon standard library."
2304+ }, {
2305+ "name": "Minimum exponent",
2306+ "symbol": "emn:fl",
2307+ "usage": "stdlib",
2308+ "link": "https://urbit.org/docs/reference/library/3b/#emn-fl",
2309+ "desc": "Used in the Hoon standard library."
2310+ }, {
2311+ "name": "Exact multiply",
2312+ "symbol": "emu:fl",
2313+ "usage": "stdlib",
2314+ "link": "https://urbit.org/docs/reference/library/3b/#emu-fl",
2315+ "desc": "Used in the Hoon standard library."
2316+ }, {
2317+ "name": "Maximum exponent",
2318+ "symbol": "emx:fl",
2319+ "usage": "stdlib",
2320+ "link": "https://urbit.org/docs/reference/library/3b/#emx-fl",
2321+ "desc": "Used in the Hoon standard library."
2322+ }, {
2323+ "name": "Tail",
2324+ "symbol": "end",
2325+ "usage": "stdlib",
2326+ "link": "https://urbit.org/docs/reference/library/2c/#end",
2327+ "desc": "Used in the Hoon standard library."
2328+ }, {
2329+ "name": "Equals (IEEE float)",
2330+ "symbol": "equ:ff",
2331+ "usage": "stdlib",
2332+ "link": "https://urbit.org/docs/reference/library/3b/#equ-ff",
2333+ "desc": "Used in the Hoon standard library."
2334+ }, {
2335+ "name": "Equals (signed and unsigned integer cell)",
2336+ "symbol": "equ:fl",
2337+ "usage": "stdlib",
2338+ "link": "https://urbit.org/docs/reference/library/3b/#equ-fl",
2339+ "desc": "Used in the Hoon standard library."
2340+ }, {
2341+ "name": "Equals (double-precision float)",
2342+ "symbol": "equ:rd",
2343+ "usage": "stdlib",
2344+ "link": "https://urbit.org/docs/reference/library/3b/#equ-rd",
2345+ "desc": "Used in the Hoon standard library."
2346+ }, {
2347+ "name": "Equals (half-precision float)",
2348+ "symbol": "equ:rh",
2349+ "usage": "stdlib",
2350+ "link": "https://urbit.org/docs/reference/library/3b/#equ-rh",
2351+ "desc": "Used in the Hoon standard library."
2352+ }, {
2353+ "name": "Equals (single-precision float)",
2354+ "symbol": "equ:rs",
2355+ "usage": "stdlib",
2356+ "link": "https://urbit.org/docs/reference/library/3b/#equ-rs",
2357+ "desc": "Used in the Hoon standard library."
2358+ }, {
2359+ "name": "Equals (quad-precision float)",
2360+ "symbol": "equ:rq",
2361+ "usage": "stdlib",
2362+ "link": "https://urbit.org/docs/reference/library/3b/#equ-rq",
2363+ "desc": "Used in the Hoon standard library."
2364+ }, {
2365+ "name": "Leap-year period",
2366+ "symbol": "era:yo",
2367+ "usage": "stdlib",
2368+ "link": "https://urbit.org/docs/reference/library/3c/#era-yo",
2369+ "desc": "Used in the Hoon standard library."
2370+ }, {
2371+ "name": "Get exponent (IEEE float)",
2372+ "symbol": "exp:ff",
2373+ "usage": "stdlib",
2374+ "link": "https://urbit.org/docs/reference/library/3b/#exp-ff",
2375+ "desc": "Used in the Hoon standard library."
2376+ }, {
2377+ "name": "Exponent (modular base)",
2378+ "symbol": "exp:fo",
2379+ "usage": "stdlib",
2380+ "link": "https://urbit.org/docs/reference/library/3a/#exp-fo",
2381+ "desc": "Used in the Hoon standard library."
2382+ }, {
2383+ "name": "Exponent (@rd)",
2384+ "symbol": "exp:rd",
2385+ "usage": "stdlib",
2386+ "link": "https://urbit.org/docs/reference/library/3b/#exp-rd",
2387+ "desc": "Used in the Hoon standard library."
2388+ }, {
2389+ "name": "Exponent (half-precision float)",
2390+ "symbol": "exp:rh",
2391+ "usage": "stdlib",
2392+ "link": "https://urbit.org/docs/reference/library/3b/#exp-rh",
2393+ "desc": "Used in the Hoon standard library."
2394+ }, {
2395+ "name": "Exponent (@rs)",
2396+ "symbol": "exp:rs",
2397+ "usage": "stdlib",
2398+ "link": "https://urbit.org/docs/reference/library/3b/#exp-rs",
2399+ "desc": "Used in the Hoon standard library."
2400+ }, {
2401+ "name": "Exponent (quad-precision float)",
2402+ "symbol": "exp:rq",
2403+ "usage": "stdlib",
2404+ "link": "https://urbit.org/docs/reference/library/3b/#exp-rq",
2405+ "desc": "Used in the Hoon standard library."
2406+ }, {
2407+ "name": "Never parse",
2408+ "symbol": "fail",
2409+ "usage": "stdlib",
2410+ "link": "https://urbit.org/docs/reference/library/4e/#fail",
2411+ "desc": "Used in the Hoon standard library."
2412+ }, {
2413+ "name": "Give unit a default value",
2414+ "symbol": "fall",
2415+ "usage": "stdlib",
2416+ "link": "https://urbit.org/docs/reference/library/2a/#fall",
2417+ "desc": "Used in the Hoon standard library."
2418+ }, {
2419+ "name": "All indices in list",
2420+ "symbol": "fand",
2421+ "usage": "stdlib",
2422+ "link": "https://urbit.org/docs/reference/library/2b/#fand",
2423+ "desc": "Used in the Hoon standard library."
2424+ }, {
2425+ "name": "Parse / (fas)",
2426+ "symbol": "fas",
2427+ "usage": "stdlib",
2428+ "link": "https://urbit.org/docs/reference/library/4h/#fas",
2429+ "desc": "Used in the Hoon standard library."
2430+ }, {
2431+ "name": "Modulo bloq",
2432+ "symbol": "fe",
2433+ "usage": "stdlib",
2434+ "link": "https://urbit.org/docs/reference/library/2c/#fe",
2435+ "desc": "Used in the Hoon standard library."
2436+ }, {
2437+ "name": "Parse @p",
2438+ "symbol": "fed:ag",
2439+ "usage": "stdlib",
2440+ "link": "https://urbit.org/docs/reference/library/4j/#fed-ag",
2441+ "desc": "Used in the Hoon standard library."
2442+ }, {
2443+ "name": "Conceal structure v2",
2444+ "symbol": "feen:ob",
2445+ "usage": "stdlib",
2446+ "link": "https://urbit.org/docs/reference/library/3f/#feen-ob",
2447+ "desc": "Used in the Hoon standard library."
2448+ }, {
2449+ "name": "Restore structure v2",
2450+ "symbol": "fend:ob",
2451+ "usage": "stdlib",
2452+ "link": "https://urbit.org/docs/reference/library/3f/#fend-ob",
2453+ "desc": "Used in the Hoon standard library."
2454+ }, {
2455+ "name": "Feistel-like cipher",
2456+ "symbol": "fice:ob",
2457+ "usage": "stdlib",
2458+ "link": "https://urbit.org/docs/reference/library/3f/#fice-ob",
2459+ "desc": "Used in the Hoon standard library."
2460+ }, {
2461+ "name": "Fill bloqstream",
2462+ "symbol": "fil",
2463+ "usage": "stdlib",
2464+ "link": "https://urbit.org/docs/reference/library/2c/#fil",
2465+ "desc": "Used in the Hoon standard library."
2466+ }, {
2467+ "name": "First index in list",
2468+ "symbol": "find",
2469+ "usage": "stdlib",
2470+ "link": "https://urbit.org/docs/reference/library/2b/#find",
2471+ "desc": "Used in the Hoon standard library."
2472+ }, {
2473+ "name": "Fit on one line test",
2474+ "symbol": "fit:re",
2475+ "usage": "stdlib",
2476+ "link": "https://urbit.org/docs/reference/library/4c/#fit-re",
2477+ "desc": "Used in the Hoon standard library."
2478+ }, {
2479+ "name": "Flip sign",
2480+ "symbol": "fli:fl",
2481+ "usage": "stdlib",
2482+ "link": "https://urbit.org/docs/reference/library/3b/#fli-fl",
2483+ "desc": "Used in the Hoon standard library."
2484+ }, {
2485+ "name": "Reverse list",
2486+ "symbol": "flop",
2487+ "usage": "stdlib",
2488+ "link": "https://urbit.org/docs/reference/library/2b/#flop",
2489+ "desc": "Used in the Hoon standard library."
2490+ }, {
2491+ "name": "Fused multiply-add (IEEE float)",
2492+ "symbol": "fma:ff",
2493+ "usage": "stdlib",
2494+ "link": "https://urbit.org/docs/reference/library/3b/#fma-ff",
2495+ "desc": "Used in the Hoon standard library."
2496+ }, {
2497+ "name": "Fused multiply-add",
2498+ "symbol": "fma:fl",
2499+ "usage": "stdlib",
2500+ "link": "https://urbit.org/docs/reference/library/3b/#fma-fl",
2501+ "desc": "Used in the Hoon standard library."
2502+ }, {
2503+ "name": "Fused multiply-add (@rd)",
2504+ "symbol": "fma:rd",
2505+ "usage": "stdlib",
2506+ "link": "https://urbit.org/docs/reference/library/3b/#fma-rd",
2507+ "desc": "Used in the Hoon standard library."
2508+ }, {
2509+ "name": "Fused multiply-add (half-precision float)",
2510+ "symbol": "fma:rh",
2511+ "usage": "stdlib",
2512+ "link": "https://urbit.org/docs/reference/library/3b/#fma-rh",
2513+ "desc": "Used in the Hoon standard library."
2514+ }, {
2515+ "name": "Fused multiply-add (single-precision float)",
2516+ "symbol": "fma:rs",
2517+ "usage": "stdlib",
2518+ "link": "https://urbit.org/docs/reference/library/3b/#fma-rs",
2519+ "desc": "Used in the Hoon standard library."
2520+ }, {
2521+ "name": "Fused multiply-add (quad-precision float)",
2522+ "symbol": "fma:rq",
2523+ "usage": "stdlib",
2524+ "link": "https://urbit.org/docs/reference/library/3b/#fma-rq",
2525+ "desc": "Used in the Hoon standard library."
2526+ }, {
2527+ "name": "FNV scrambler",
2528+ "symbol": "fnv",
2529+ "usage": "stdlib",
2530+ "link": "https://urbit.org/docs/reference/library/2e/#fnv",
2531+ "desc": "Used in the Hoon standard library."
2532+ }, {
2533+ "name": "Modulo prime",
2534+ "symbol": "fo",
2535+ "usage": "stdlib",
2536+ "link": "https://urbit.org/docs/reference/library/3a/#fo",
2537+ "desc": "Used in the Hoon standard library."
2538+ }, {
2539+ "name": "Cases of arms by variance model",
2540+ "symbol": "foot",
2541+ "usage": "stdlib",
2542+ "link": "https://urbit.org/docs/reference/library/4o/#foot",
2543+ "desc": "Used in the Hoon standard library."
2544+ }, {
2545+ "name": "@rs to @rh",
2546+ "symbol": "fos:rh",
2547+ "usage": "stdlib",
2548+ "link": "https://urbit.org/docs/reference/library/3b/#fos-rh",
2549+ "desc": "Used in the Hoon standard library."
2550+ }, {
2551+ "name": "Divide (modular base)",
2552+ "symbol": "fra:fo",
2553+ "usage": "stdlib",
2554+ "link": "https://urbit.org/docs/reference/library/3a/#fra-fo",
2555+ "desc": "Used in the Hoon standard library."
2556+ }, {
2557+ "name": "Divide (signed integer)",
2558+ "symbol": "fra:si",
2559+ "usage": "stdlib",
2560+ "link": "https://urbit.org/docs/reference/library/3a/#fra-si",
2561+ "desc": "Used in the Hoon standard library."
2562+ }, {
2563+ "name": "Parse to end",
2564+ "symbol": "full",
2565+ "usage": "stdlib",
2566+ "link": "https://urbit.org/docs/reference/library/4f/#full",
2567+ "desc": "Used in the Hoon standard library."
2568+ }, {
2569+ "name": "Add to tape",
2570+ "symbol": "funk",
2571+ "usage": "stdlib",
2572+ "link": "https://urbit.org/docs/reference/library/4f/#funk",
2573+ "desc": "Used in the Hoon standard library."
2574+ }, {
2575+ "name": "New line or ''",
2576+ "symbol": "gah",
2577+ "usage": "stdlib",
2578+ "link": "https://urbit.org/docs/reference/library/4i/#gah",
2579+ "desc": "Used in the Hoon standard library."
2580+ }, {
2581+ "name": "Parse < (gal)",
2582+ "symbol": "gal",
2583+ "usage": "stdlib",
2584+ "link": "https://urbit.org/docs/reference/library/4h/#gal",
2585+ "desc": "Used in the Hoon standard library."
2586+ }, {
2587+ "name": "Plural whitespace",
2588+ "symbol": "gap",
2589+ "usage": "stdlib",
2590+ "link": "https://urbit.org/docs/reference/library/4i/#gap",
2591+ "desc": "Used in the Hoon standard library."
2592+ }, {
2593+ "name": "End of line",
2594+ "symbol": "gaq",
2595+ "usage": "stdlib",
2596+ "link": "https://urbit.org/docs/reference/library/4i/#gaq",
2597+ "desc": "Used in the Hoon standard library."
2598+ }, {
2599+ "name": "Parse > (gar)",
2600+ "symbol": "gar",
2601+ "usage": "stdlib",
2602+ "link": "https://urbit.org/docs/reference/library/4h/#gar",
2603+ "desc": "Used in the Hoon standard library."
2604+ }, {
2605+ "name": "Concatenate (map)",
2606+ "symbol": "gas:by",
2607+ "usage": "stdlib",
2608+ "link": "https://urbit.org/docs/reference/library/2i/#gas-by",
2609+ "desc": "Used in the Hoon standard library."
2610+ }, {
2611+ "name": "Concatenate (set)",
2612+ "symbol": "gas:in",
2613+ "usage": "stdlib",
2614+ "link": "https://urbit.org/docs/reference/library/2h/#gas-in",
2615+ "desc": "Used in the Hoon standard library."
2616+ }, {
2617+ "name": "Push list into queue",
2618+ "symbol": "gas:to",
2619+ "usage": "stdlib",
2620+ "link": "https://urbit.org/docs/reference/library/2k/#gas-to",
2621+ "desc": "Used in the Hoon standard library."
2622+ }, {
2623+ "name": "Function",
2624+ "symbol": "gate",
2625+ "usage": "stdlib",
2626+ "link": "https://urbit.org/docs/reference/library/1c/#gate",
2627+ "desc": "Used in the Hoon standard library."
2628+ }, {
2629+ "name": "Classic whitespace",
2630+ "symbol": "gaw",
2631+ "usage": "stdlib",
2632+ "link": "https://urbit.org/docs/reference/library/4i/#gaw",
2633+ "desc": "Used in the Hoon standard library."
2634+ }, {
2635+ "name": "Optional gap",
2636+ "symbol": "gay",
2637+ "usage": "stdlib",
2638+ "link": "https://urbit.org/docs/reference/library/4i/#gay",
2639+ "desc": "Used in the Hoon standard library."
2640+ }, {
2641+ "name": "Grab unit value",
2642+ "symbol": "get:by",
2643+ "usage": "stdlib",
2644+ "link": "https://urbit.org/docs/reference/library/2i/#get-by",
2645+ "desc": "Used in the Hoon standard library."
2646+ }, {
2647+ "name": "Grab value by key",
2648+ "symbol": "get:ja",
2649+ "usage": "stdlib",
2650+ "link": "https://urbit.org/docs/reference/library/2j/#get-ja",
2651+ "desc": "Used in the Hoon standard library."
2652+ }, {
2653+ "name": "Retrieve set",
2654+ "symbol": "get:ju",
2655+ "usage": "stdlib",
2656+ "link": "https://urbit.org/docs/reference/library/2j/#get-ju",
2657+ "desc": "Used in the Hoon standard library."
2658+ }, {
2659+ "name": "Head-tail pair",
2660+ "symbol": "get:to",
2661+ "usage": "stdlib",
2662+ "link": "https://urbit.org/docs/reference/library/2k/#get-to",
2663+ "desc": "Used in the Hoon standard library."
2664+ }, {
2665+ "name": "Skip delimiter",
2666+ "symbol": "glue",
2667+ "usage": "stdlib",
2668+ "link": "https://urbit.org/docs/reference/library/4e/#glue",
2669+ "desc": "Used in the Hoon standard library."
2670+ }, {
2671+ "name": "Parse long numbers",
2672+ "symbol": "gon",
2673+ "usage": "stdlib",
2674+ "link": "https://urbit.org/docs/reference/library/4i/#gon",
2675+ "desc": "Used in the Hoon standard library."
2676+ }, {
2677+ "name": "Hash order",
2678+ "symbol": "gor",
2679+ "usage": "stdlib",
2680+ "link": "https://urbit.org/docs/reference/library/2f/#gor",
2681+ "desc": "Used in the Hoon standard library."
2682+ }, {
2683+ "name": "Assert for value (map)",
2684+ "symbol": "got:by",
2685+ "usage": "stdlib",
2686+ "link": "https://urbit.org/docs/reference/library/2i/#got-by",
2687+ "desc": "Used in the Hoon standard library."
2688+ }, {
2689+ "name": "Decimal float to @r",
2690+ "symbol": "grd:ff",
2691+ "usage": "stdlib",
2692+ "link": "https://urbit.org/docs/reference/library/3b/#grd-ff",
2693+ "desc": "Used in the Hoon standard library."
2694+ }, {
2695+ "name": "Decimal to float",
2696+ "symbol": "grd:fl",
2697+ "usage": "stdlib",
2698+ "link": "https://urbit.org/docs/reference/library/3b/#grd-fl",
2699+ "desc": "Used in the Hoon standard library."
2700+ }, {
2701+ "name": "Decimal float to @rd",
2702+ "symbol": "grd:rd",
2703+ "usage": "stdlib",
2704+ "link": "https://urbit.org/docs/reference/library/3b/#grd-rd",
2705+ "desc": "Used in the Hoon standard library."
2706+ }, {
2707+ "name": "Decimal float to @rh",
2708+ "symbol": "grd:rh",
2709+ "usage": "stdlib",
2710+ "link": "https://urbit.org/docs/reference/library/3b/#grd-rh",
2711+ "desc": "Used in the Hoon standard library."
2712+ }, {
2713+ "name": "Decimal float to @rs",
2714+ "symbol": "grd:rs",
2715+ "usage": "stdlib",
2716+ "link": "https://urbit.org/docs/reference/library/3b/#grd-rs",
2717+ "desc": "Used in the Hoon standard library."
2718+ }, {
2719+ "name": "Decimal float to @rq",
2720+ "symbol": "grd:rq",
2721+ "usage": "stdlib",
2722+ "link": "https://urbit.org/docs/reference/library/3b/#grd-rq",
2723+ "desc": "Used in the Hoon standard library."
2724+ }, {
2725+ "name": "Greater than / equal",
2726+ "symbol": "gte",
2727+ "usage": "stdlib",
2728+ "link": "https://urbit.org/docs/reference/library/1a/#gte",
2729+ "desc": "Used in the Hoon standard library."
2730+ }, {
2731+ "name": "Greater than / equal (IEEE float)",
2732+ "symbol": "gte:ff",
2733+ "usage": "stdlib",
2734+ "link": "https://urbit.org/docs/reference/library/3b/#gte-ff",
2735+ "desc": "Used in the Hoon standard library."
2736+ }, {
2737+ "name": "Greater than / equal (producing flag)",
2738+ "symbol": "gte:fl",
2739+ "usage": "stdlib",
2740+ "link": "https://urbit.org/docs/reference/library/3b/#gte-fl",
2741+ "desc": "Used in the Hoon standard library."
2742+ }, {
2743+ "name": "Greater than / equal (double-precision float)",
2744+ "symbol": "gte:rd",
2745+ "usage": "stdlib",
2746+ "link": "https://urbit.org/docs/reference/library/3b/#gte-rd",
2747+ "desc": "Used in the Hoon standard library."
2748+ }, {
2749+ "name": "Greater than / equal (half-precision float)",
2750+ "symbol": "gte:rh",
2751+ "usage": "stdlib",
2752+ "link": "https://urbit.org/docs/reference/library/3b/#gte-rh",
2753+ "desc": "Used in the Hoon standard library."
2754+ }, {
2755+ "name": "Greater than / equal (single-precision float)",
2756+ "symbol": "gte:rs",
2757+ "usage": "stdlib",
2758+ "link": "https://urbit.org/docs/reference/library/3b/#gte-rs",
2759+ "desc": "Used in the Hoon standard library."
2760+ }, {
2761+ "name": "Greater than / equal (quad-precision float)",
2762+ "symbol": "gte:rq",
2763+ "usage": "stdlib",
2764+ "link": "https://urbit.org/docs/reference/library/3b/#gte-rq",
2765+ "desc": "Used in the Hoon standard library."
2766+ }, {
2767+ "name": "Greater than",
2768+ "symbol": "gth",
2769+ "usage": "stdlib",
2770+ "link": "https://urbit.org/docs/reference/library/1a/#gth",
2771+ "desc": "Used in the Hoon standard library."
2772+ }, {
2773+ "name": "Greater than (IEEE float)",
2774+ "symbol": "gth:ff",
2775+ "usage": "stdlib",
2776+ "link": "https://urbit.org/docs/reference/library/3b/#gth-ff",
2777+ "desc": "Used in the Hoon standard library."
2778+ }, {
2779+ "name": "Greater than (producing flag)",
2780+ "symbol": "gth:fl",
2781+ "usage": "stdlib",
2782+ "link": "https://urbit.org/docs/reference/library/3b/#gth-fl",
2783+ "desc": "Used in the Hoon standard library."
2784+ }, {
2785+ "name": "Greater than (double-precision float)",
2786+ "symbol": "gth:rd",
2787+ "usage": "stdlib",
2788+ "link": "https://urbit.org/docs/reference/library/3b/#gth-rd",
2789+ "desc": "Used in the Hoon standard library."
2790+ }, {
2791+ "name": "Greater than (half-precision float)",
2792+ "symbol": "gth:rh",
2793+ "usage": "stdlib",
2794+ "link": "https://urbit.org/docs/reference/library/3b/#gth-rh",
2795+ "desc": "Used in the Hoon standard library."
2796+ }, {
2797+ "name": "Greater than (single-precision float)",
2798+ "symbol": "gth:rs",
2799+ "usage": "stdlib",
2800+ "link": "https://urbit.org/docs/reference/library/3b/#gth-rs",
2801+ "desc": "Used in the Hoon standard library."
2802+ }, {
2803+ "name": "Greater than (quad-precision float)",
2804+ "symbol": "gth:rq",
2805+ "usage": "stdlib",
2806+ "link": "https://urbit.org/docs/reference/library/3b/#gth-rq",
2807+ "desc": "Used in the Hoon standard library."
2808+ }, {
2809+ "name": "Axis syntax < or >",
2810+ "symbol": "gul",
2811+ "usage": "stdlib",
2812+ "link": "https://urbit.org/docs/reference/library/4i/#gul",
2813+ "desc": "Used in the Hoon standard library."
2814+ }, {
2815+ "name": "List from range",
2816+ "symbol": "gulf",
2817+ "usage": "stdlib",
2818+ "link": "https://urbit.org/docs/reference/library/2b/#gulf",
2819+ "desc": "Used in the Hoon standard library."
2820+ }, {
2821+ "name": "Parsing line and column",
2822+ "symbol": "hair",
2823+ "usage": "stdlib",
2824+ "link": "https://urbit.org/docs/reference/library/3g/#hair",
2825+ "desc": "Used in the Hoon standard library."
2826+ }, {
2827+ "name": "Force remold",
2828+ "symbol": "hard",
2829+ "usage": "stdlib",
2830+ "link": "https://urbit.org/docs/reference/library/2n/#hard",
2831+ "desc": "Used in the Hoon standard library."
2832+ }, {
2833+ "name": "Key existence check (map)",
2834+ "symbol": "has:by",
2835+ "usage": "stdlib",
2836+ "link": "https://urbit.org/docs/reference/library/2i/#has-by",
2837+ "desc": "Used in the Hoon standard library."
2838+ }, {
2839+ "name": "Key existence check (set)",
2840+ "symbol": "has:in",
2841+ "usage": "stdlib",
2842+ "link": "https://urbit.org/docs/reference/library/2h/#has-in",
2843+ "desc": "Used in the Hoon standard library."
2844+ }, {
2845+ "name": "Check contents (jug)",
2846+ "symbol": "has:ju",
2847+ "usage": "stdlib",
2848+ "link": "https://urbit.org/docs/reference/library/2j/#has-ju",
2849+ "desc": "Used in the Hoon standard library."
2850+ }, {
2851+ "name": "Parse # (hax)",
2852+ "symbol": "hax",
2853+ "usage": "stdlib",
2854+ "link": "https://urbit.org/docs/reference/library/4h/#hax",
2855+ "desc": "Used in the Hoon standard library."
2856+ }, {
2857+ "name": "Get head of cell",
2858+ "symbol": "head",
2859+ "usage": "stdlib",
2860+ "link": "https://urbit.org/docs/reference/library/2n/#head",
2861+ "desc": "Used in the Hoon standard library."
2862+ }, {
2863+ "name": "Place-based apply",
2864+ "symbol": "here",
2865+ "usage": "stdlib",
2866+ "link": "https://urbit.org/docs/reference/library/4f/#here",
2867+ "desc": "Used in the Hoon standard library."
2868+ }, {
2869+ "name": "Parse - (hep)",
2870+ "symbol": "hep",
2871+ "usage": "stdlib",
2872+ "link": "https://urbit.org/docs/reference/library/4h/#hep",
2873+ "desc": "Used in the Hoon standard library."
2874+ }, {
2875+ "name": "Hexadecimal to atom",
2876+ "symbol": "hex",
2877+ "usage": "stdlib",
2878+ "link": "https://urbit.org/docs/reference/library/4i/#hex",
2879+ "desc": "Used in the Hoon standard library."
2880+ }, {
2881+ "name": "Parse hexadecimal number",
2882+ "symbol": "hex:ag",
2883+ "usage": "stdlib",
2884+ "link": "https://urbit.org/docs/reference/library/4j/#hex-ag",
2885+ "desc": "Used in the Hoon standard library."
2886+ }, {
2887+ "name": "Parse phonetic pair",
2888+ "symbol": "hif:ab",
2889+ "usage": "stdlib",
2890+ "link": "https://urbit.org/docs/reference/library/4j/#hif-ab",
2891+ "desc": "Used in the Hoon standard library."
2892+ }, {
2893+ "name": "Parse single uppercase letter",
2894+ "symbol": "hig",
2895+ "usage": "stdlib",
2896+ "link": "https://urbit.org/docs/reference/library/4i/#hig",
2897+ "desc": "Used in the Hoon standard library."
2898+ }, {
2899+ "name": "Parse single hexadecimal digit",
2900+ "symbol": "hit",
2901+ "usage": "stdlib",
2902+ "link": "https://urbit.org/docs/reference/library/4i/#hit",
2903+ "desc": "Used in the Hoon standard library."
2904+ }, {
2905+ "name": "Homogenize list",
2906+ "symbol": "homo",
2907+ "usage": "stdlib",
2908+ "link": "https://urbit.org/docs/reference/library/2b/#homo",
2909+ "desc": "Used in the Hoon standard library."
2910+ }, {
2911+ "name": "Horizontal hash order",
2912+ "symbol": "hor",
2913+ "usage": "stdlib",
2914+ "link": "https://urbit.org/docs/reference/library/2f/#hor",
2915+ "desc": "Used in the Hoon standard library."
2916+ }, {
2917+ "name": "Seconds in hour",
2918+ "symbol": "hor:yo",
2919+ "usage": "stdlib",
2920+ "link": "https://urbit.org/docs/reference/library/3c/#hor-yo",
2921+ "desc": "Used in the Hoon standard library."
2922+ }, {
2923+ "name": "Parse two phonetic pairs",
2924+ "symbol": "huf:ab",
2925+ "usage": "stdlib",
2926+ "link": "https://urbit.org/docs/reference/library/4j/#huf-ab",
2927+ "desc": "Used in the Hoon standard library."
2928+ }, {
2929+ "name": "Parse 8 phonetic bytes",
2930+ "symbol": "hyf:ab",
2931+ "usage": "stdlib",
2932+ "link": "https://urbit.org/docs/reference/library/4j/#hyf-ab",
2933+ "desc": "Used in the Hoon standard library."
2934+ }, {
2935+ "name": "Integer binary logarithm",
2936+ "symbol": "ibl:fl",
2937+ "usage": "stdlib",
2938+ "link": "https://urbit.org/docs/reference/library/3b/#ibl-fl",
2939+ "desc": "Used in the Hoon standard library."
2940+ }, {
2941+ "name": "Infix",
2942+ "symbol": "ifix",
2943+ "usage": "stdlib",
2944+ "link": "https://urbit.org/docs/reference/library/4f/#ifix",
2945+ "desc": "Used in the Hoon standard library."
2946+ }, {
2947+ "name": "Parse suffix",
2948+ "symbol": "ind:po",
2949+ "usage": "stdlib",
2950+ "link": "https://urbit.org/docs/reference/library/4a/#ind-po",
2951+ "desc": "Used in the Hoon standard library."
2952+ }, {
2953+ "name": "Parse prefix",
2954+ "symbol": "ins:po",
2955+ "usage": "stdlib",
2956+ "link": "https://urbit.org/docs/reference/library/4a/#ins-po",
2957+ "desc": "Used in the Hoon standard library."
2958+ }, {
2959+ "name": "Intersection (map)",
2960+ "symbol": "int:by",
2961+ "usage": "stdlib",
2962+ "link": "https://urbit.org/docs/reference/library/2i/#int-by",
2963+ "desc": "Used in the Hoon standard library."
2964+ }, {
2965+ "name": "Intersection (set)",
2966+ "symbol": "int:in",
2967+ "usage": "stdlib",
2968+ "link": "https://urbit.org/docs/reference/library/2h/#int-in",
2969+ "desc": "Used in the Hoon standard library."
2970+ }, {
2971+ "name": "Inverse order of modular field",
2972+ "symbol": "inv:fe",
2973+ "usage": "stdlib",
2974+ "link": "https://urbit.org/docs/reference/library/2c/#inv-fe",
2975+ "desc": "Used in the Hoon standard library."
2976+ }, {
2977+ "name": "Inverse",
2978+ "symbol": "inv:fl",
2979+ "usage": "stdlib",
2980+ "link": "https://urbit.org/docs/reference/library/3b/#inv-fl",
2981+ "desc": "Used in the Hoon standard library."
2982+ }, {
2983+ "name": "Inverse (signed modulus)",
2984+ "symbol": "inv:fo",
2985+ "usage": "stdlib",
2986+ "link": "https://urbit.org/docs/reference/library/3a/#inv-fo",
2987+ "desc": "Used in the Hoon standard library."
2988+ }, {
2989+ "name": "Indentation block",
2990+ "symbol": "iny",
2991+ "usage": "stdlib",
2992+ "link": "https://urbit.org/docs/reference/library/4i/#iny",
2993+ "desc": "Used in the Hoon standard library."
2994+ }, {
2995+ "name": "Jar engine",
2996+ "symbol": "ja",
2997+ "usage": "stdlib",
2998+ "link": "https://urbit.org/docs/reference/library/2j/#ja",
2999+ "desc": "Used in the Hoon standard library."
3000+ }, {
3001+ "name": "Pack noun to atom",
3002+ "symbol": "jam",
3003+ "usage": "stdlib",
3004+ "link": "https://urbit.org/docs/reference/library/2p/#jam",
3005+ "desc": "Used in the Hoon standard library."
3006+ }, {
3007+ "name": "Mold generator (jar)",
3008+ "symbol": "jar",
3009+ "usage": "stdlib",
3010+ "link": "https://urbit.org/docs/reference/library/2o/#jar",
3011+ "desc": "Used in the Hoon standard library."
3012+ }, {
3013+ "name": "Maximum 64-bit timestamp",
3014+ "symbol": "jes:yo",
3015+ "usage": "stdlib",
3016+ "link": "https://urbit.org/docs/reference/library/3c/#jes-yo",
3017+ "desc": "Used in the Hoon standard library."
3018+ }, {
3019+ "name": "Match a cord",
3020+ "symbol": "jest",
3021+ "usage": "stdlib",
3022+ "link": "https://urbit.org/docs/reference/library/4f/#jest",
3023+ "desc": "Used in the Hoon standard library."
3024+ }, {
3025+ "name": "Add separator between list elements",
3026+ "symbol": "join",
3027+ "usage": "stdlib",
3028+ "link": "https://urbit.org/docs/reference/library/2b/#join",
3029+ "desc": "Used in the Hoon standard library."
3030+ }, {
3031+ "name": "Jug operations",
3032+ "symbol": "ju",
3033+ "usage": "stdlib",
3034+ "link": "https://urbit.org/docs/reference/library/2j/#ju",
3035+ "desc": "Used in the Hoon standard library."
3036+ }, {
3037+ "name": "Mold generator (jug)",
3038+ "symbol": "jug",
3039+ "usage": "stdlib",
3040+ "link": "https://urbit.org/docs/reference/library/2o/#jug",
3041+ "desc": "Used in the Hoon standard library."
3042+ }, {
3043+ "name": "Match a single character",
3044+ "symbol": "just",
3045+ "usage": "stdlib",
3046+ "link": "https://urbit.org/docs/reference/library/4f/#just",
3047+ "desc": "Used in the Hoon standard library."
3048+ }, {
3049+ "name": "Parse { (kel)",
3050+ "symbol": "kel",
3051+ "usage": "stdlib",
3052+ "link": "https://urbit.org/docs/reference/library/4h/#kel",
3053+ "desc": "Used in the Hoon standard library."
3054+ }, {
3055+ "name": "Parse } (ker)",
3056+ "symbol": "ker",
3057+ "usage": "stdlib",
3058+ "link": "https://urbit.org/docs/reference/library/4h/#ker",
3059+ "desc": "Used in the Hoon standard library."
3060+ }, {
3061+ "name": "Parse ^ (ket)",
3062+ "symbol": "ket",
3063+ "usage": "stdlib",
3064+ "link": "https://urbit.org/docs/reference/library/4h/#ket",
3065+ "desc": "Used in the Hoon standard library."
3066+ }, {
3067+ "name": "Recursive parsers",
3068+ "symbol": "knee",
3069+ "usage": "stdlib",
3070+ "link": "https://urbit.org/docs/reference/library/4f/#knee",
3071+ "desc": "Used in the Hoon standard library."
3072+ }, {
3073+ "name": "Atom type of ASCII characters",
3074+ "symbol": "knot",
3075+ "usage": "stdlib",
3076+ "link": "https://urbit.org/docs/reference/library/2q/#knot",
3077+ "desc": "Used in the Hoon standard library."
3078+ }, {
3079+ "name": "Further trace",
3080+ "symbol": "last",
3081+ "usage": "stdlib",
3082+ "link": "https://urbit.org/docs/reference/library/4d/#last",
3083+ "desc": "Used in the Hoon standard library."
3084+ }, {
3085+ "name": "Construct list from null-terminated noun",
3086+ "symbol": "le:nl",
3087+ "usage": "stdlib",
3088+ "link": "https://urbit.org/docs/reference/library/2m/#le-nl",
3089+ "desc": "Used in the Hoon standard library."
3090+ }, {
3091+ "name": "List length",
3092+ "symbol": "lent",
3093+ "usage": "stdlib",
3094+ "link": "https://urbit.org/docs/reference/library/2b/#lent",
3095+ "desc": "Used in the Hoon standard library."
3096+ }, {
3097+ "name": "Logical AND on list",
3098+ "symbol": "levy",
3099+ "usage": "stdlib",
3100+ "link": "https://urbit.org/docs/reference/library/2b/#levy",
3101+ "desc": "Used in the Hoon standard library."
3102+ }, {
3103+ "name": "Maximum",
3104+ "symbol": "lfe:fl",
3105+ "usage": "stdlib",
3106+ "link": "https://urbit.org/docs/reference/library/3b/#lfe-fl",
3107+ "desc": "Used in the Hoon standard library."
3108+ }, {
3109+ "name": "Largest normal float",
3110+ "symbol": "lfn:fl",
3111+ "usage": "stdlib",
3112+ "link": "https://urbit.org/docs/reference/library/3b/#lfn-fl",
3113+ "desc": "Used in the Hoon standard library."
3114+ }, {
3115+ "name": "Logical OR on list",
3116+ "symbol": "lien",
3117+ "usage": "stdlib",
3118+ "link": "https://urbit.org/docs/reference/library/2b/#lien",
3119+ "desc": "Used in the Hoon standard library."
3120+ }, {
3121+ "name": "Curried bind",
3122+ "symbol": "lift",
3123+ "usage": "stdlib",
3124+ "link": "https://urbit.org/docs/reference/library/2a/#lift",
3125+ "desc": "Used in the Hoon standard library."
3126+ }, {
3127+ "name": "Generic edge",
3128+ "symbol": "like",
3129+ "usage": "stdlib",
3130+ "link": "https://urbit.org/docs/reference/library/3g/#like",
3131+ "desc": "Used in the Hoon standard library."
3132+ }, {
3133+ "name": "Reference into subject by name/axis",
3134+ "symbol": "limb",
3135+ "usage": "stdlib",
3136+ "link": "https://urbit.org/docs/reference/library/4o/#limb",
3137+ "desc": "Used in the Hoon standard library."
3138+ }, {
3139+ "name": "Construct list from null-terminated tuple",
3140+ "symbol": "limo",
3141+ "usage": "stdlib",
3142+ "link": "https://urbit.org/docs/reference/library/2b/#limo",
3143+ "desc": "Used in the Hoon standard library."
3144+ }, {
3145+ "name": "(Undocumented)",
3146+ "symbol": "line",
3147+ "usage": "stdlib",
3148+ "link": "https://urbit.org/docs/reference/library/4o/#line",
3149+ "desc": "Used in the Hoon standard library."
3150+ }, {
3151+ "name": "Parse IPv4 address",
3152+ "symbol": "lip:ag",
3153+ "usage": "stdlib",
3154+ "link": "https://urbit.org/docs/reference/library/4j/#lip-ag",
3155+ "desc": "Used in the Hoon standard library."
3156+ }, {
3157+ "name": "Mold constructor (list)",
3158+ "symbol": "list",
3159+ "usage": "stdlib",
3160+ "link": "https://urbit.org/docs/reference/library/1c/#list",
3161+ "desc": "Used in the Hoon standard library."
3162+ }, {
3163+ "name": "Mold generator (face on mold)",
3164+ "symbol": "lone",
3165+ "usage": "stdlib",
3166+ "link": "https://urbit.org/docs/reference/library/1c/#lone",
3167+ "desc": "Used in the Hoon standard library."
3168+ }, {
3169+ "name": "Leg order",
3170+ "symbol": "lor",
3171+ "usage": "stdlib",
3172+ "link": "https://urbit.org/docs/reference/library/2f/#lor",
3173+ "desc": "Used in the Hoon standard library."
3174+ }, {
3175+ "name": "Parse lowercase letter",
3176+ "symbol": "low",
3177+ "usage": "stdlib",
3178+ "link": "https://urbit.org/docs/reference/library/4i/#low",
3179+ "desc": "Used in the Hoon standard library."
3180+ }, {
3181+ "name": "Left-shift",
3182+ "symbol": "lsh",
3183+ "usage": "stdlib",
3184+ "link": "https://urbit.org/docs/reference/library/2c/#lsh",
3185+ "desc": "Used in the Hoon standard library."
3186+ }, {
3187+ "name": "Less than / equal (atom)",
3188+ "symbol": "lte",
3189+ "usage": "stdlib",
3190+ "link": "https://urbit.org/docs/reference/library/1a/#lte",
3191+ "desc": "Used in the Hoon standard library."
3192+ }, {
3193+ "name": "Less than / equal (IEEE float)",
3194+ "symbol": "lte:ff",
3195+ "usage": "stdlib",
3196+ "link": "https://urbit.org/docs/reference/library/3b/#lte-ff",
3197+ "desc": "Used in the Hoon standard library."
3198+ }, {
3199+ "name": "Less than / equal (producing flag)",
3200+ "symbol": "lte:fl",
3201+ "usage": "stdlib",
3202+ "link": "https://urbit.org/docs/reference/library/3b/#lte-fl",
3203+ "desc": "Used in the Hoon standard library."
3204+ }, {
3205+ "name": "Less than / equal (double-precision float)",
3206+ "symbol": "lte:rd",
3207+ "usage": "stdlib",
3208+ "link": "https://urbit.org/docs/reference/library/3b/#lte-rd",
3209+ "desc": "Used in the Hoon standard library."
3210+ }, {
3211+ "name": "Less than / equal (half-precision float)",
3212+ "symbol": "lte:rh",
3213+ "usage": "stdlib",
3214+ "link": "https://urbit.org/docs/reference/library/3b/#lte-rh",
3215+ "desc": "Used in the Hoon standard library."
3216+ }, {
3217+ "name": "Less than / equal (single-precision float)",
3218+ "symbol": "lte:rs",
3219+ "usage": "stdlib",
3220+ "link": "https://urbit.org/docs/reference/library/3b/#lte-rs",
3221+ "desc": "Used in the Hoon standard library."
3222+ }, {
3223+ "name": "Less than / equal (quad-precision float)",
3224+ "symbol": "lte:rq",
3225+ "usage": "stdlib",
3226+ "link": "https://urbit.org/docs/reference/library/3b/#lte-rq",
3227+ "desc": "Used in the Hoon standard library."
3228+ }, {
3229+ "name": "Less than (atom)",
3230+ "symbol": "lth",
3231+ "usage": "stdlib",
3232+ "link": "https://urbit.org/docs/reference/library/1a/#lth",
3233+ "desc": "Used in the Hoon standard library."
3234+ }, {
3235+ "name": "Less than (IEEE float)",
3236+ "symbol": "lth:ff",
3237+ "usage": "stdlib",
3238+ "link": "https://urbit.org/docs/reference/library/3b/#lth-ff",
3239+ "desc": "Used in the Hoon standard library."
3240+ }, {
3241+ "name": "Less than (signed and unsigned integer cell)",
3242+ "symbol": "lth:fl",
3243+ "usage": "stdlib",
3244+ "link": "https://urbit.org/docs/reference/library/3b/#lth-fl",
3245+ "desc": "Used in the Hoon standard library."
3246+ }, {
3247+ "name": "Less than (double-precision float)",
3248+ "symbol": "lth:rd",
3249+ "usage": "stdlib",
3250+ "link": "https://urbit.org/docs/reference/library/3b/#lth-rd",
3251+ "desc": "Used in the Hoon standard library."
3252+ }, {
3253+ "name": "Less than (half-precision float)",
3254+ "symbol": "lth:rh",
3255+ "usage": "stdlib",
3256+ "link": "https://urbit.org/docs/reference/library/3b/#lth-rh",
3257+ "desc": "Used in the Hoon standard library."
3258+ }, {
3259+ "name": "Less than (single-precision float)",
3260+ "symbol": "lth:rs",
3261+ "usage": "stdlib",
3262+ "link": "https://urbit.org/docs/reference/library/3b/#lth-rs",
3263+ "desc": "Used in the Hoon standard library."
3264+ }, {
3265+ "name": "Less than (quad-precision float)",
3266+ "symbol": "lth:rq",
3267+ "usage": "stdlib",
3268+ "link": "https://urbit.org/docs/reference/library/3b/#lth-rq",
3269+ "desc": "Used in the Hoon standard library."
3270+ }, {
3271+ "name": "Central rounding mechanism",
3272+ "symbol": "lug:fl",
3273+ "usage": "stdlib",
3274+ "link": "https://urbit.org/docs/reference/library/3b/#lug-fl",
3275+ "desc": "Used in the Hoon standard library."
3276+ }, {
3277+ "name": "Parse + (lus)",
3278+ "symbol": "lus",
3279+ "usage": "stdlib",
3280+ "link": "https://urbit.org/docs/reference/library/4h/#lus",
3281+ "desc": "Used in the Hoon standard library."
3282+ }, {
3283+ "name": "Detect new line",
3284+ "symbol": "lust",
3285+ "usage": "stdlib",
3286+ "link": "https://urbit.org/docs/reference/library/4d/#lust",
3287+ "desc": "Used in the Hoon standard library."
3288+ }, {
3289+ "name": "Parse unless",
3290+ "symbol": "less",
3291+ "usage": "stdlib",
3292+ "link": "https://urbit.org/docs/reference/library/4e/#less",
3293+ "desc": "Used in the Hoon standard library."
3294+ }, {
3295+ "name": "List from raw noun",
3296+ "symbol": "ly",
3297+ "usage": "stdlib",
3298+ "link": "https://urbit.org/docs/reference/library/2m/#ly",
3299+ "desc": "Used in the Hoon standard library."
3300+ }, {
3301+ "name": "Initialize ff (rd core)",
3302+ "symbol": "ma:rd",
3303+ "usage": "stdlib",
3304+ "link": "https://urbit.org/docs/reference/library/3b/#ma-rd",
3305+ "desc": "Used in the Hoon standard library."
3306+ }, {
3307+ "name": "Initialize ff (rh core)",
3308+ "symbol": "ma:rh",
3309+ "usage": "stdlib",
3310+ "link": "https://urbit.org/docs/reference/library/3b/#ma-rh",
3311+ "desc": "Used in the Hoon standard library."
3312+ }, {
3313+ "name": "Initialize ff (rs core)",
3314+ "symbol": "ma:rs",
3315+ "usage": "stdlib",
3316+ "link": "https://urbit.org/docs/reference/library/3b/#ma-rs",
3317+ "desc": "Used in the Hoon standard library."
3318+ }, {
3319+ "name": "Initialize ff (rq core)",
3320+ "symbol": "ma:rq",
3321+ "usage": "stdlib",
3322+ "link": "https://urbit.org/docs/reference/library/3b/#ma-rq",
3323+ "desc": "Used in the Hoon standard library."
3324+ }, {
3325+ "name": "Nock subject to unit",
3326+ "symbol": "mack",
3327+ "usage": "stdlib",
3328+ "link": "https://urbit.org/docs/reference/library/4n/#mack",
3329+ "desc": "Used in the Hoon standard library."
3330+ }, {
3331+ "name": "Map from list",
3332+ "symbol": "malt",
3333+ "usage": "stdlib",
3334+ "link": "https://urbit.org/docs/reference/library/2l/#malt",
3335+ "desc": "Used in the Hoon standard library."
3336+ }, {
3337+ "name": "Mold generator (map)",
3338+ "symbol": "map",
3339+ "usage": "stdlib",
3340+ "link": "https://urbit.org/docs/reference/library/2o/#map",
3341+ "desc": "Used in the Hoon standard library."
3342+ }, {
3343+ "name": "Assert and add (map)",
3344+ "symbol": "mar:by",
3345+ "usage": "stdlib",
3346+ "link": "https://urbit.org/docs/reference/library/2i/#mar-by",
3347+ "desc": "Used in the Hoon standard library."
3348+ }, {
3349+ "name": "Address within head/tail",
3350+ "symbol": "mas",
3351+ "usage": "stdlib",
3352+ "link": "https://urbit.org/docs/reference/library/1b/#mas",
3353+ "desc": "Used in the Hoon standard library."
3354+ }, {
3355+ "name": "Match character",
3356+ "symbol": "mask",
3357+ "usage": "stdlib",
3358+ "link": "https://urbit.org/docs/reference/library/4f/#mask",
3359+ "desc": "Used in the Hoon standard library."
3360+ }, {
3361+ "name": "Length-encode",
3362+ "symbol": "mat",
3363+ "usage": "stdlib",
3364+ "link": "https://urbit.org/docs/reference/library/2p/#mat",
3365+ "desc": "Used in the Hoon standard library."
3366+ }, {
3367+ "name": "Choose",
3368+ "symbol": "mate",
3369+ "usage": "stdlib",
3370+ "link": "https://urbit.org/docs/reference/library/2a/#mate",
3371+ "desc": "Used in the Hoon standard library."
3372+ }, {
3373+ "name": "Maximum",
3374+ "symbol": "max",
3375+ "usage": "stdlib",
3376+ "link": "https://urbit.org/docs/reference/library/1a/#max",
3377+ "desc": "Used in the Hoon standard library."
3378+ }, {
3379+ "name": "Minimum exponent of ff",
3380+ "symbol": "me:ff",
3381+ "usage": "stdlib",
3382+ "link": "https://urbit.org/docs/reference/library/3b/#me-ff",
3383+ "desc": "Used in the Hoon standard library."
3384+ }, {
3385+ "name": "Crash and printf",
3386+ "symbol": "mean",
3387+ "usage": "stdlib",
3388+ "link": "https://urbit.org/docs/reference/library/2n/#mean",
3389+ "desc": "Used in the Hoon standard library."
3390+ }, {
3391+ "name": "Parse hexabyte",
3392+ "symbol": "mes",
3393+ "usage": "stdlib",
3394+ "link": "https://urbit.org/docs/reference/library/4i/#mes",
3395+ "desc": "Used in the Hoon standard library."
3396+ }, {
3397+ "name": "Escape special characters",
3398+ "symbol": "mesc",
3399+ "usage": "stdlib",
3400+ "link": "https://urbit.org/docs/reference/library/4b/#mesc",
3401+ "desc": "Used in the Hoon standard library."
3402+ }, {
3403+ "name": "Measure",
3404+ "symbol": "met",
3405+ "usage": "stdlib",
3406+ "link": "https://urbit.org/docs/reference/library/2c/#met",
3407+ "desc": "Used in the Hoon standard library."
3408+ }, {
3409+ "name": "(Undocumented)",
3410+ "symbol": "metl",
3411+ "usage": "stdlib",
3412+ "link": "https://urbit.org/docs/reference/library/4o/#metl",
3413+ "desc": "Used in the Hoon standard library."
3414+ }, {
3415+ "name": "Minimum (atom)",
3416+ "symbol": "min",
3417+ "usage": "stdlib",
3418+ "link": "https://urbit.org/docs/reference/library/1a/#min",
3419+ "desc": "Used in the Hoon standard library."
3420+ }, {
3421+ "name": "Mock (virtual Nock) interpreter",
3422+ "symbol": "mink",
3423+ "usage": "stdlib",
3424+ "link": "https://urbit.org/docs/reference/library/4n/#mink",
3425+ "desc": "Used in the Hoon standard library."
3426+ }, {
3427+ "name": "Seconds in minute",
3428+ "symbol": "mit:yo",
3429+ "usage": "stdlib",
3430+ "link": "https://urbit.org/docs/reference/library/3c/#mit-yo",
3431+ "desc": "Used in the Hoon standard library."
3432+ }, {
3433+ "name": "Binary XOR (atom)",
3434+ "symbol": "mix",
3435+ "usage": "stdlib",
3436+ "link": "https://urbit.org/docs/reference/library/2d/#mix",
3437+ "desc": "Used in the Hoon standard library."
3438+ }, {
3439+ "name": "Compute formula on subject with hint",
3440+ "symbol": "mock",
3441+ "usage": "stdlib",
3442+ "link": "https://urbit.org/docs/reference/library/4n/#mock",
3443+ "desc": "Used in the Hoon standard library."
3444+ }, {
3445+ "name": "Modulus (atom)",
3446+ "symbol": "mod",
3447+ "usage": "stdlib",
3448+ "link": "https://urbit.org/docs/reference/library/1a/#mod",
3449+ "desc": "Used in the Hoon standard library."
3450+ }, {
3451+ "name": "Days in month",
3452+ "symbol": "moh:yo",
3453+ "usage": "stdlib",
3454+ "link": "https://urbit.org/docs/reference/library/3c/#moh-yo",
3455+ "desc": "Used in the Hoon standard library."
3456+ }, {
3457+ "name": "Map from pair list",
3458+ "symbol": "molt",
3459+ "usage": "stdlib",
3460+ "link": "https://urbit.org/docs/reference/library/2l/#molt",
3461+ "desc": "Used in the Hoon standard library."
3462+ }, {
3463+ "name": "Slam gate with sample",
3464+ "symbol": "mong",
3465+ "usage": "stdlib",
3466+ "link": "https://urbit.org/docs/reference/library/4n/#mong",
3467+ "desc": "Used in the Hoon standard library."
3468+ }, {
3469+ "name": "Intelligently render crash annotation",
3470+ "symbol": "mook",
3471+ "usage": "stdlib",
3472+ "link": "https://urbit.org/docs/reference/library/4n/#mook",
3473+ "desc": "Used in the Hoon standard library."
3474+ }, {
3475+ "name": "Parse list with delimiter",
3476+ "symbol": "more",
3477+ "usage": "stdlib",
3478+ "link": "https://urbit.org/docs/reference/library/4f/#more",
3479+ "desc": "Used in the Hoon standard library."
3480+ }, {
3481+ "name": "Parse list of at least one match",
3482+ "symbol": "most",
3483+ "usage": "stdlib",
3484+ "link": "https://urbit.org/docs/reference/library/4f/#most",
3485+ "desc": "Used in the Hoon standard library."
3486+ }, {
3487+ "name": "Days in months of leap-year",
3488+ "symbol": "moy:yo",
3489+ "usage": "stdlib",
3490+ "link": "https://urbit.org/docs/reference/library/3c/#moy-yo",
3491+ "desc": "Used in the Hoon standard library."
3492+ }, {
3493+ "name": "Core used to scramble 16-bit atoms",
3494+ "symbol": "mu",
3495+ "usage": "stdlib",
3496+ "link": "https://urbit.org/docs/reference/library/4j/#mu",
3497+ "desc": "Used in the Hoon standard library."
3498+ }, {
3499+ "name": "FNV-1a scrambler",
3500+ "symbol": "mug",
3501+ "usage": "stdlib",
3502+ "link": "https://urbit.org/docs/reference/library/2e/#mug",
3503+ "desc": "Used in the Hoon standard library."
3504+ }, {
3505+ "name": "Standard MurmurHash3",
3506+ "symbol": "muk",
3507+ "usage": "stdlib",
3508+ "link": "https://urbit.org/docs/reference/library/2e/#muk",
3509+ "desc": "Used in the Hoon standard library."
3510+ }, {
3511+ "name": "Multiply (atom)",
3512+ "symbol": "mul",
3513+ "usage": "stdlib",
3514+ "link": "https://urbit.org/docs/reference/library/1a/#mul",
3515+ "desc": "Used in the Hoon standard library."
3516+ }, {
3517+ "name": "Multiply (IEEE float)",
3518+ "symbol": "mul:ff",
3519+ "usage": "stdlib",
3520+ "link": "https://urbit.org/docs/reference/library/3b/#mul-ff",
3521+ "desc": "Used in the Hoon standard library."
3522+ }, {
3523+ "name": "Multiply (signed and unsigned integer cell)",
3524+ "symbol": "mul:fl",
3525+ "usage": "stdlib",
3526+ "link": "https://urbit.org/docs/reference/library/3b/#mul-fl",
3527+ "desc": "Used in the Hoon standard library."
3528+ }, {
3529+ "name": "Multiply (double-precision float)",
3530+ "symbol": "mul:rd",
3531+ "usage": "stdlib",
3532+ "link": "https://urbit.org/docs/reference/library/3b/#mul-rd",
3533+ "desc": "Used in the Hoon standard library."
3534+ }, {
3535+ "name": "Multiply (quad-precision float)",
3536+ "symbol": "mul:rh",
3537+ "usage": "stdlib",
3538+ "link": "https://urbit.org/docs/reference/library/3b/#mul-rh",
3539+ "desc": "Used in the Hoon standard library."
3540+ }, {
3541+ "name": "Multiply (single-precision float)",
3542+ "symbol": "mul:rs",
3543+ "usage": "stdlib",
3544+ "link": "https://urbit.org/docs/reference/library/3b/#mul-rs",
3545+ "desc": "Used in the Hoon standard library."
3546+ }, {
3547+ "name": "Multiply (quad-precision float)",
3548+ "symbol": "mul:rq",
3549+ "usage": "stdlib",
3550+ "link": "https://urbit.org/docs/reference/library/3b/#mul-rq",
3551+ "desc": "Used in the Hoon standard library."
3552+ }, {
3553+ "name": "Typed virtual",
3554+ "symbol": "mule",
3555+ "usage": "stdlib",
3556+ "link": "https://urbit.org/docs/reference/library/4n/#mule",
3557+ "desc": "Used in the Hoon standard library."
3558+ }, {
3559+ "name": "Untyped virtual",
3560+ "symbol": "mute",
3561+ "usage": "stdlib",
3562+ "link": "https://urbit.org/docs/reference/library/4n/#mute",
3563+ "desc": "Used in the Hoon standard library."
3564+ }, {
3565+ "name": "31-bit MurmurHash3 scrambler",
3566+ "symbol": "mum",
3567+ "usage": "stdlib",
3568+ "link": "https://urbit.org/docs/reference/library/2e/#mum",
3569+ "desc": "Used in the Hoon standard library."
3570+ }, {
3571+ "name": "Maybe transform",
3572+ "symbol": "murn",
3573+ "usage": "stdlib",
3574+ "link": "https://urbit.org/docs/reference/library/2b/#murn",
3575+ "desc": "Used in the Hoon standard library."
3576+ }, {
3577+ "name": "Map from raw noun",
3578+ "symbol": "my",
3579+ "usage": "stdlib",
3580+ "link": "https://urbit.org/docs/reference/library/2m/#my",
3581+ "desc": "Used in the Hoon standard library."
3582+ }, {
3583+ "name": "Construct map from null-terminated noun",
3584+ "symbol": "my:nl",
3585+ "usage": "stdlib",
3586+ "link": "https://urbit.org/docs/reference/library/2m/#my-nl",
3587+ "desc": "Used in the Hoon standard library."
3588+ }, {
3589+ "name": "Location, remainder of parsed text",
3590+ "symbol": "nail",
3591+ "usage": "stdlib",
3592+ "link": "https://urbit.org/docs/reference/library/3g/#nail",
3593+ "desc": "Used in the Hoon standard library."
3594+ }, {
3595+ "name": "Remove head of queue",
3596+ "symbol": "nap:to",
3597+ "usage": "stdlib",
3598+ "link": "https://urbit.org/docs/reference/library/2k/#nap-to",
3599+ "desc": "Used in the Hoon standard library."
3600+ }, {
3601+ "name": "Digit rendering engine",
3602+ "symbol": "ne",
3603+ "usage": "stdlib",
3604+ "link": "https://urbit.org/docs/reference/library/4j/#ne",
3605+ "desc": "Used in the Hoon standard library."
3606+ }, {
3607+ "name": "Require float",
3608+ "symbol": "ned:fl",
3609+ "usage": "stdlib",
3610+ "link": "https://urbit.org/docs/reference/library/3b/#ned-fl",
3611+ "desc": "Used in the Hoon standard library."
3612+ }, {
3613+ "name": "Unwrap unit",
3614+ "symbol": "need",
3615+ "usage": "stdlib",
3616+ "link": "https://urbit.org/docs/reference/library/2a/#need",
3617+ "desc": "Used in the Hoon standard library."
3618+ }, {
3619+ "name": "Flip endianness",
3620+ "symbol": "net:fe",
3621+ "usage": "stdlib",
3622+ "link": "https://urbit.org/docs/reference/library/2c/#net-fe",
3623+ "desc": "Used in the Hoon standard library."
3624+ }, {
3625+ "name": "Atom to @s",
3626+ "symbol": "new:si",
3627+ "usage": "stdlib",
3628+ "link": "https://urbit.org/docs/reference/library/3a/#new-si",
3629+ "desc": "Used in the Hoon standard library."
3630+ }, {
3631+ "name": "Consume character",
3632+ "symbol": "next",
3633+ "usage": "stdlib",
3634+ "link": "https://urbit.org/docs/reference/library/4f/#next",
3635+ "desc": "Used in the Hoon standard library."
3636+ }, {
3637+ "name": "Remove root of queue",
3638+ "symbol": "nip:to",
3639+ "usage": "stdlib",
3640+ "link": "https://urbit.org/docs/reference/library/2k/#nip-to",
3641+ "desc": "Used in the Hoon standard library."
3642+ }, {
3643+ "name": "Parse letters and -",
3644+ "symbol": "nix",
3645+ "usage": "stdlib",
3646+ "link": "https://urbit.org/docs/reference/library/4i/#nix",
3647+ "desc": "Used in the Hoon standard library."
3648+ }, {
3649+ "name": "Noun to container operations",
3650+ "symbol": "nl",
3651+ "usage": "stdlib",
3652+ "link": "https://urbit.org/docs/reference/library/2m/#nl",
3653+ "desc": "Used in the Hoon standard library."
3654+ }, {
3655+ "name": "Virtual machine (see Nock)",
3656+ "symbol": "nock",
3657+ "usage": "stdlib",
3658+ "link": "https://urbit.org/docs/reference/library/4o/#nock",
3659+ "desc": "Used in the Hoon standard library."
3660+ }, {
3661+ "name": "Binary NOT (atom)",
3662+ "symbol": "not",
3663+ "usage": "stdlib",
3664+ "link": "https://urbit.org/docs/reference/library/2d/#not",
3665+ "desc": "Used in the Hoon standard library."
3666+ }, {
3667+ "name": "(Undocumented)",
3668+ "symbol": "noun",
3669+ "usage": "stdlib",
3670+ "link": "https://urbit.org/docs/reference/library/4o/#noun",
3671+ "desc": "Used in the Hoon standard library."
3672+ }, {
3673+ "name": "Top-level coin parser",
3674+ "symbol": "nuck:so",
3675+ "usage": "stdlib",
3676+ "link": "https://urbit.org/docs/reference/library/4l/#nuck-so",
3677+ "desc": "Used in the Hoon standard library."
3678+ }, {
3679+ "name": "Parse numeric character",
3680+ "symbol": "nud",
3681+ "usage": "stdlib",
3682+ "link": "https://urbit.org/docs/reference/library/4i/#nud",
3683+ "desc": "Used in the Hoon standard library."
3684+ }, {
3685+ "name": "(Undocumented)",
3686+ "symbol": "null",
3687+ "usage": "stdlib",
3688+ "link": "https://urbit.org/docs/reference/library/4o/#null",
3689+ "desc": "Used in the Hoon standard library."
3690+ }, {
3691+ "name": "Parse coin literal with escapes",
3692+ "symbol": "nusk:so",
3693+ "usage": "stdlib",
3694+ "link": "https://urbit.org/docs/reference/library/4l/#nusk-so",
3695+ "desc": "Used in the Hoon standard library."
3696+ }, {
3697+ "name": "Reversible scrambling v2",
3698+ "symbol": "ob",
3699+ "usage": "stdlib",
3700+ "link": "https://urbit.org/docs/reference/library/3f/#ob",
3701+ "desc": "Used in the Hoon standard library."
3702+ }, {
3703+ "name": "Container arm for SHA-256 powered RNG",
3704+ "symbol": "og",
3705+ "usage": "stdlib",
3706+ "link": "https://urbit.org/docs/reference/library/3d/#og",
3707+ "desc": "Used in the Hoon standard library."
3708+ }, {
3709+ "name": "Sign and absolute value",
3710+ "symbol": "old:si",
3711+ "usage": "stdlib",
3712+ "link": "https://urbit.org/docs/reference/library/3a/#old-si",
3713+ "desc": "Used in the Hoon standard library."
3714+ }, {
3715+ "name": "Remove from list",
3716+ "symbol": "oust",
3717+ "usage": "stdlib",
3718+ "link": "https://urbit.org/docs/reference/library/2b/#oust",
3719+ "desc": "Used in the Hoon standard library."
3720+ }, {
3721+ "name": "Maximum integer value",
3722+ "symbol": "out:fe",
3723+ "usage": "stdlib",
3724+ "link": "https://urbit.org/docs/reference/library/2c/#out-fe",
3725+ "desc": "Used in the Hoon standard library."
3726+ }, {
3727+ "name": "Initialize fl from ff core",
3728+ "symbol": "pa:ff",
3729+ "usage": "stdlib",
3730+ "link": "https://urbit.org/docs/reference/library/3b/#pa-ff",
3731+ "desc": "Used in the Hoon standard library."
3732+ }, {
3733+ "name": "Mold of pair of types",
3734+ "symbol": "pair",
3735+ "usage": "stdlib",
3736+ "link": "https://urbit.org/docs/reference/library/1c/#pair",
3737+ "desc": "Used in the Hoon standard library."
3738+ }, {
3739+ "name": "Parse & (pam)",
3740+ "symbol": "pam",
3741+ "usage": "stdlib",
3742+ "link": "https://urbit.org/docs/reference/library/4h/#pam",
3743+ "desc": "Used in the Hoon standard library."
3744+ }, {
3745+ "name": "Parse @ (pat)",
3746+ "symbol": "pat",
3747+ "usage": "stdlib",
3748+ "link": "https://urbit.org/docs/reference/library/4h/#pat",
3749+ "desc": "Used in the Hoon standard library."
3750+ }, {
3751+ "name": "Filesystem path",
3752+ "symbol": "path",
3753+ "usage": "stdlib",
3754+ "link": "https://urbit.org/docs/reference/library/3g/#path",
3755+ "desc": "Used in the Hoon standard library."
3756+ }, {
3757+ "name": "Address within address",
3758+ "symbol": "peg",
3759+ "usage": "stdlib",
3760+ "link": "https://urbit.org/docs/reference/library/1b/#peg",
3761+ "desc": "Used in the Hoon standard library."
3762+ }, {
3763+ "name": "Parse ( (pel)",
3764+ "symbol": "pel",
3765+ "usage": "stdlib",
3766+ "link": "https://urbit.org/docs/reference/library/4h/#pel",
3767+ "desc": "Used in the Hoon standard library."
3768+ }, {
3769+ "name": "Parse ) (per)",
3770+ "symbol": "per",
3771+ "usage": "stdlib",
3772+ "link": "https://urbit.org/docs/reference/library/4h/#per",
3773+ "desc": "Used in the Hoon standard library."
3774+ }, {
3775+ "name": "Parses dime/tiple without standard prefixes",
3776+ "symbol": "perd:so",
3777+ "usage": "stdlib",
3778+ "link": "https://urbit.org/docs/reference/library/4l/#perd-so",
3779+ "desc": "Used in the Hoon standard library."
3780+ }, {
3781+ "name": "Parse <=5 in base 32",
3782+ "symbol": "pev:ab",
3783+ "usage": "stdlib",
3784+ "link": "https://urbit.org/docs/reference/library/4j/#pev-ab",
3785+ "desc": "Used in the Hoon standard library."
3786+ }, {
3787+ "name": "Parse <= 5 in base 64",
3788+ "symbol": "pew:ab",
3789+ "usage": "stdlib",
3790+ "link": "https://urbit.org/docs/reference/library/4j/#pew-ab",
3791+ "desc": "Used in the Hoon standard library."
3792+ }, {
3793+ "name": "Discard first rule",
3794+ "symbol": "pfix",
3795+ "usage": "stdlib",
3796+ "link": "https://urbit.org/docs/reference/library/4e/#pfix",
3797+ "desc": "Used in the Hoon standard library."
3798+ }, {
3799+ "name": "Parsing range",
3800+ "symbol": "pint",
3801+ "usage": "stdlib",
3802+ "link": "https://urbit.org/docs/reference/library/3g/#pint",
3803+ "desc": "Used in the Hoon standard library."
3804+ }, {
3805+ "name": "Parse 5 digits in base 32",
3806+ "symbol": "piv:ab",
3807+ "usage": "stdlib",
3808+ "link": "https://urbit.org/docs/reference/library/4j/#piv-ab",
3809+ "desc": "Used in the Hoon standard library."
3810+ }, {
3811+ "name": "Parse 5 digits in base 64",
3812+ "symbol": "piw:ab",
3813+ "usage": "stdlib",
3814+ "link": "https://urbit.org/docs/reference/library/4j/#piw-ab",
3815+ "desc": "Used in the Hoon standard library."
3816+ }, {
3817+ "name": "Parse to tuple",
3818+ "symbol": "plug",
3819+ "usage": "stdlib",
3820+ "link": "https://urbit.org/docs/reference/library/4e/#plug",
3821+ "desc": "Used in the Hoon standard library."
3822+ }, {
3823+ "name": "List of at least one match",
3824+ "symbol": "plus",
3825+ "usage": "stdlib",
3826+ "link": "https://urbit.org/docs/reference/library/4f/#plus",
3827+ "desc": "Used in the Hoon standard library."
3828+ }, {
3829+ "name": "Phonetic base",
3830+ "symbol": "po",
3831+ "usage": "stdlib",
3832+ "link": "https://urbit.org/docs/reference/library/4a/#po",
3833+ "desc": "Used in the Hoon standard library."
3834+ }, {
3835+ "name": "Mold generator of faceless list",
3836+ "symbol": "pole",
3837+ "usage": "stdlib",
3838+ "link": "https://urbit.org/docs/reference/library/1c/#pole",
3839+ "desc": "Used in the Hoon standard library."
3840+ }, {
3841+ "name": "(Undocumented)",
3842+ "symbol": "port",
3843+ "usage": "stdlib",
3844+ "link": "https://urbit.org/docs/reference/library/4o/#port",
3845+ "desc": "Used in the Hoon standard library."
3846+ }, {
3847+ "name": "Parse options",
3848+ "symbol": "pose",
3849+ "usage": "stdlib",
3850+ "link": "https://urbit.org/docs/reference/library/4e/#pose",
3851+ "desc": "Used in the Hoon standard library."
3852+ }, {
3853+ "name": "Computes a to the power of b",
3854+ "symbol": "pow",
3855+ "usage": "stdlib",
3856+ "link": "https://urbit.org/docs/reference/library/2g/#pow",
3857+ "desc": "Used in the Hoon standard library."
3858+ }, {
3859+ "name": "Force precision of 2 or greater (floating point)",
3860+ "symbol": "prc:fl",
3861+ "usage": "stdlib",
3862+ "link": "https://urbit.org/docs/reference/library/3b/#prc-fl",
3863+ "desc": "Used in the Hoon standard library."
3864+ }, {
3865+ "name": "Parse any printable character",
3866+ "symbol": "prn",
3867+ "usage": "stdlib",
3868+ "link": "https://urbit.org/docs/reference/library/4i/#prn",
3869+ "desc": "Used in the Hoon standard library."
3870+ }, {
3871+ "name": "Multiplies b and c modulo a",
3872+ "symbol": "pro:fo",
3873+ "usage": "stdlib",
3874+ "link": "https://urbit.org/docs/reference/library/3a/#pro-fo",
3875+ "desc": "Used in the Hoon standard library."
3876+ }, {
3877+ "name": "Multiply to signed integer",
3878+ "symbol": "pro:si",
3879+ "usage": "stdlib",
3880+ "link": "https://urbit.org/docs/reference/library/3a/#pro-si",
3881+ "desc": "Used in the Hoon standard library."
3882+ }, {
3883+ "name": "Add key-value pair (map)",
3884+ "symbol": "put:by",
3885+ "usage": "stdlib",
3886+ "link": "https://urbit.org/docs/reference/library/2i/#put-by",
3887+ "desc": "Used in the Hoon standard library."
3888+ }, {
3889+ "name": "Put b in a (set)",
3890+ "symbol": "put:in",
3891+ "usage": "stdlib",
3892+ "link": "https://urbit.org/docs/reference/library/2h/#put-in",
3893+ "desc": "Used in the Hoon standard library."
3894+ }, {
3895+ "name": "Add key-set pair (jar)",
3896+ "symbol": "put:ju",
3897+ "usage": "stdlib",
3898+ "link": "https://urbit.org/docs/reference/library/2j/#put-ju",
3899+ "desc": "Used in the Hoon standard library."
3900+ }, {
3901+ "name": "Insert into queue",
3902+ "symbol": "put:to",
3903+ "usage": "stdlib",
3904+ "link": "https://urbit.org/docs/reference/library/2k/#put-to",
3905+ "desc": "Used in the Hoon standard library."
3906+ }, {
3907+ "name": "Seconds in 4 years",
3908+ "symbol": "qad:yo",
3909+ "usage": "stdlib",
3910+ "link": "https://urbit.org/docs/reference/library/3c/#qad-yo",
3911+ "desc": "Used in the Hoon standard library."
3912+ }, {
3913+ "name": "Parse <=4 binary digits",
3914+ "symbol": "qeb:ab",
3915+ "usage": "stdlib",
3916+ "link": "https://urbit.org/docs/reference/library/4j/#qeb-ab",
3917+ "desc": "Used in the Hoon standard library."
3918+ }, {
3919+ "name": "Mold generator (queue)",
3920+ "symbol": "qeu",
3921+ "usage": "stdlib",
3922+ "link": "https://urbit.org/docs/reference/library/2o/#qeu",
3923+ "desc": "Used in the Hoon standard library."
3924+ }, {
3925+ "name": "Parse <=4 hexadecimal digits",
3926+ "symbol": "qex:ab",
3927+ "usage": "stdlib",
3928+ "link": "https://urbit.org/docs/reference/library/4j/#qex-ab",
3929+ "desc": "Used in the Hoon standard library."
3930+ }, {
3931+ "name": "Parse 4 binary digits",
3932+ "symbol": "qib:ab",
3933+ "usage": "stdlib",
3934+ "link": "https://urbit.org/docs/reference/library/4j/#qib-ab",
3935+ "desc": "Used in the Hoon standard library."
3936+ }, {
3937+ "name": "Parse character to cord atom",
3938+ "symbol": "qit",
3939+ "usage": "stdlib",
3940+ "link": "https://urbit.org/docs/reference/library/4i/#qit",
3941+ "desc": "Used in the Hoon standard library."
3942+ }, {
3943+ "name": "Parse 4 hexadecimal digits",
3944+ "symbol": "qix:ab",
3945+ "usage": "stdlib",
3946+ "link": "https://urbit.org/docs/reference/library/4j/#qix-ab",
3947+ "desc": "Used in the Hoon standard library."
3948+ }, {
3949+ "name": "Mold generator (tuple of list and type)",
3950+ "symbol": "quip",
3951+ "usage": "stdlib",
3952+ "link": "https://urbit.org/docs/reference/library/1c/#quip",
3953+ "desc": "Used in the Hoon standard library."
3954+ }, {
3955+ "name": "Parse cord",
3956+ "symbol": "qut",
3957+ "usage": "stdlib",
3958+ "link": "https://urbit.org/docs/reference/library/4i/#qut",
3959+ "desc": "Used in the Hoon standard library."
3960+ }, {
3961+ "name": "(Undocumented)",
3962+ "symbol": "r:at",
3963+ "usage": "stdlib",
3964+ "link": "https://urbit.org/docs/reference/library/4b/#r-at",
3965+ "desc": "Used in the Hoon standard library."
3966+ }, {
3967+ "name": "Random in range",
3968+ "symbol": "rad:og",
3969+ "usage": "stdlib",
3970+ "link": "https://urbit.org/docs/reference/library/3d/#rad-og",
3971+ "desc": "Used in the Hoon standard library."
3972+ }, {
3973+ "name": "Random continuation",
3974+ "symbol": "rads:og",
3975+ "usage": "stdlib",
3976+ "link": "https://urbit.org/docs/reference/library/3d/#rads-og",
3977+ "desc": "Used in the Hoon standard library."
3978+ }, {
3979+ "name": "Key list",
3980+ "symbol": "raku:ob",
3981+ "usage": "stdlib",
3982+ "link": "https://urbit.org/docs/reference/library/3f/#raku-ob",
3983+ "desc": "Used in the Hoon standard library."
3984+ }, {
3985+ "name": "Flatten tank to tape",
3986+ "symbol": "ram:re",
3987+ "usage": "stdlib",
3988+ "link": "https://urbit.org/docs/reference/library/4c/#ram-re",
3989+ "desc": "Used in the Hoon standard library."
3990+ }, {
3991+ "name": "Assemble non-zero",
3992+ "symbol": "rap",
3993+ "usage": "stdlib",
3994+ "link": "https://urbit.org/docs/reference/library/2c/#rap",
3995+ "desc": "Used in the Hoon standard library."
3996+ }, {
3997+ "name": "Parse or crash",
3998+ "symbol": "rash",
3999+ "usage": "stdlib",
4000+ "link": "https://urbit.org/docs/reference/library/4g/#rash",
4001+ "desc": "Used in the Hoon standard library."
4002+ }, {
4003+ "name": "Various roundings (floating point)",
4004+ "symbol": "rau:fl",
4005+ "usage": "stdlib",
4006+ "link": "https://urbit.org/docs/reference/library/3b/#rau-fl",
4007+ "desc": "Used in the Hoon standard library."
4008+ }, {
4009+ "name": "Random bits",
4010+ "symbol": "raw:og",
4011+ "usage": "stdlib",
4012+ "link": "https://urbit.org/docs/reference/library/3d/#raw-og",
4013+ "desc": "Used in the Hoon standard library."
4014+ }, {
4015+ "name": "Random bits continuation",
4016+ "symbol": "raws:og",
4017+ "usage": "stdlib",
4018+ "link": "https://urbit.org/docs/reference/library/3d/#raws-og",
4019+ "desc": "Used in the Hoon standard library."
4020+ }, {
4021+ "name": "Pretty-printing engine (tank)",
4022+ "symbol": "re",
4023+ "usage": "stdlib",
4024+ "link": "https://urbit.org/docs/reference/library/4c/#re",
4025+ "desc": "Used in the Hoon standard library."
4026+ }, {
4027+ "name": "Prepend and render atom as tape",
4028+ "symbol": "rear:co",
4029+ "usage": "stdlib",
4030+ "link": "https://urbit.org/docs/reference/library/4k/#rear-co",
4031+ "desc": "Used in the Hoon standard library."
4032+ }, {
4033+ "name": "Replicate (list)",
4034+ "symbol": "reap",
4035+ "usage": "stdlib",
4036+ "link": "https://urbit.org/docs/reference/library/2b/#reap",
4037+ "desc": "Used in the Hoon standard library."
4038+ }, {
4039+ "name": "Right fold (list)",
4040+ "symbol": "reel",
4041+ "usage": "stdlib",
4042+ "link": "https://urbit.org/docs/reference/library/2b/#reel",
4043+ "desc": "Used in the Hoon standard library."
4044+ }, {
4045+ "name": "Remainder (signed integer)",
4046+ "symbol": "rem:si",
4047+ "usage": "stdlib",
4048+ "link": "https://urbit.org/docs/reference/library/3a/#rem-si",
4049+ "desc": "Used in the Hoon standard library."
4050+ }, {
4051+ "name": "Render coin lot as tape",
4052+ "symbol": "rend:co",
4053+ "usage": "stdlib",
4054+ "link": "https://urbit.org/docs/reference/library/4k/#rend-co",
4055+ "desc": "Used in the Hoon standard library."
4056+ }, {
4057+ "name": "Render coin lot as span",
4058+ "symbol": "rent:co",
4059+ "usage": "stdlib",
4060+ "link": "https://urbit.org/docs/reference/library/4k/#rent-co",
4061+ "desc": "Used in the Hoon standard library."
4062+ }, {
4063+ "name": "Assemble single",
4064+ "symbol": "rep",
4065+ "usage": "stdlib",
4066+ "link": "https://urbit.org/docs/reference/library/2c/#rep",
4067+ "desc": "Used in the Hoon standard library."
4068+ }, {
4069+ "name": "Replace by product (map)",
4070+ "symbol": "rep:by",
4071+ "usage": "stdlib",
4072+ "link": "https://urbit.org/docs/reference/library/2i/#rep-by",
4073+ "desc": "Used in the Hoon standard library."
4074+ }, {
4075+ "name": "Accumulate elements (set)",
4076+ "symbol": "rep:in",
4077+ "usage": "stdlib",
4078+ "link": "https://urbit.org/docs/reference/library/2h/#rep-in",
4079+ "desc": "Used in the Hoon standard library."
4080+ }, {
4081+ "name": "(Undocumented)",
4082+ "symbol": "rf:at",
4083+ "usage": "stdlib",
4084+ "link": "https://urbit.org/docs/reference/library/4b/#rf-at",
4085+ "desc": "Used in the Hoon standard library."
4086+ }, {
4087+ "name": "Replace values with accumulator (map)",
4088+ "symbol": "rib:by",
4089+ "usage": "stdlib",
4090+ "link": "https://urbit.org/docs/reference/library/2i/#rib-by",
4091+ "desc": "Used in the Hoon standard library."
4092+ }, {
4093+ "name": "Wrap tape in / (tank)",
4094+ "symbol": "rig:re",
4095+ "usage": "stdlib",
4096+ "link": "https://urbit.org/docs/reference/library/4c/#rig-re",
4097+ "desc": "Used in the Hoon standard library."
4098+ }, {
4099+ "name": "Disassemble",
4100+ "symbol": "rip",
4101+ "usage": "stdlib",
4102+ "link": "https://urbit.org/docs/reference/library/2c/#rip",
4103+ "desc": "Used in the Hoon standard library."
4104+ }, {
4105+ "name": "(Undocumented)",
4106+ "symbol": "rn:at",
4107+ "usage": "stdlib",
4108+ "link": "https://urbit.org/docs/reference/library/4b/#rn-at",
4109+ "desc": "Used in the Hoon standard library."
4110+ }, {
4111+ "name": "Roll left",
4112+ "symbol": "rol:fe",
4113+ "usage": "stdlib",
4114+ "link": "https://urbit.org/docs/reference/library/2c/#rol-fe",
4115+ "desc": "Used in the Hoon standard library."
4116+ }, {
4117+ "name": "Left fold (list)",
4118+ "symbol": "roll",
4119+ "usage": "stdlib",
4120+ "link": "https://urbit.org/docs/reference/library/2b/#roll",
4121+ "desc": "Used in the Hoon standard library."
4122+ }, {
4123+ "name": "Roll right",
4124+ "symbol": "ror:fe",
4125+ "usage": "stdlib",
4126+ "link": "https://urbit.org/docs/reference/library/2c/#ror-fe",
4127+ "desc": "Used in the Hoon standard library."
4128+ }, {
4129+ "name": "Round to nearest float with 113-bit significand",
4130+ "symbol": "rou:fl",
4131+ "usage": "stdlib",
4132+ "link": "https://urbit.org/docs/reference/library/3b/#rou-fl",
4133+ "desc": "Used in the Hoon standard library."
4134+ }, {
4135+ "name": "Parse dime float",
4136+ "symbol": "royl:so",
4137+ "usage": "stdlib",
4138+ "link": "https://urbit.org/docs/reference/library/4l/#royl-so",
4139+ "desc": "Used in the Hoon standard library."
4140+ }, {
4141+ "name": "(Undocumented)",
4142+ "symbol": "royl-cell:so",
4143+ "usage": "stdlib",
4144+ "link": "https://urbit.org/docs/reference/library/4l/#royl-cell-so",
4145+ "desc": "Used in the Hoon standard library."
4146+ }, {
4147+ "name": "Right-shift",
4148+ "symbol": "rsh",
4149+ "usage": "stdlib",
4150+ "link": "https://urbit.org/docs/reference/library/2c/#rsh",
4151+ "desc": "Used in the Hoon standard library."
4152+ }, {
4153+ "name": "(Undocumented)",
4154+ "symbol": "rt:at",
4155+ "usage": "stdlib",
4156+ "link": "https://urbit.org/docs/reference/library/4b/#rt-at",
4157+ "desc": "Used in the Hoon standard library."
4158+ }, {
4159+ "name": "(Undocumented)",
4160+ "symbol": "rta:at",
4161+ "usage": "stdlib",
4162+ "link": "https://urbit.org/docs/reference/library/4b/#rta-at",
4163+ "desc": "Used in the Hoon standard library."
4164+ }, {
4165+ "name": "(Undocumented)",
4166+ "symbol": "rtam:at",
4167+ "usage": "stdlib",
4168+ "link": "https://urbit.org/docs/reference/library/4b/#rtam-at",
4169+ "desc": "Used in the Hoon standard library."
4170+ }, {
4171+ "name": "Length-decode",
4172+ "symbol": "rub",
4173+ "usage": "stdlib",
4174+ "link": "https://urbit.org/docs/reference/library/2p/#rub",
4175+ "desc": "Used in the Hoon standard library."
4176+ }, {
4177+ "name": "(Undocumented)",
4178+ "symbol": "rub:at",
4179+ "usage": "stdlib",
4180+ "link": "https://urbit.org/docs/reference/library/4b/#rub-at",
4181+ "desc": "Used in the Hoon standard library."
4182+ }, {
4183+ "name": "(Undocumented)",
4184+ "symbol": "rud:at",
4185+ "usage": "stdlib",
4186+ "link": "https://urbit.org/docs/reference/library/4b/#rud-at",
4187+ "desc": "Used in the Hoon standard library."
4188+ }, {
4189+ "name": "Parsing rule (match this with _)",
4190+ "symbol": "rule",
4191+ "usage": "stdlib",
4192+ "link": "https://urbit.org/docs/reference/library/3g/#rule",
4193+ "desc": "Used in the Hoon standard library."
4194+ }, {
4195+ "name": "(Undocumented)",
4196+ "symbol": "rum:at",
4197+ "usage": "stdlib",
4198+ "link": "https://urbit.org/docs/reference/library/4b/#rum-at",
4199+ "desc": "Used in the Hoon standard library."
4200+ }, {
4201+ "name": "Transform values (map)",
4202+ "symbol": "run:by",
4203+ "usage": "stdlib",
4204+ "link": "https://urbit.org/docs/reference/library/2i/#run-by",
4205+ "desc": "Used in the Hoon standard library."
4206+ }, {
4207+ "name": "Apply gate to set",
4208+ "symbol": "run:in",
4209+ "usage": "stdlib",
4210+ "link": "https://urbit.org/docs/reference/library/2h/#run-in",
4211+ "desc": "Used in the Hoon standard library."
4212+ }, {
4213+ "name": "Reverse single Feistel-like",
4214+ "symbol": "rund:ob",
4215+ "usage": "stdlib",
4216+ "link": "https://urbit.org/docs/reference/library/3f/#rund-ob",
4217+ "desc": "Used in the Hoon standard library."
4218+ }, {
4219+ "name": "Prepend n times",
4220+ "symbol": "runt",
4221+ "usage": "stdlib",
4222+ "link": "https://urbit.org/docs/reference/library/4b/#runt",
4223+ "desc": "Used in the Hoon standard library."
4224+ }, {
4225+ "name": "(Undocumented)",
4226+ "symbol": "rup:at",
4227+ "usage": "stdlib",
4228+ "link": "https://urbit.org/docs/reference/library/4b/#rup-at",
4229+ "desc": "Used in the Hoon standard library."
4230+ }, {
4231+ "name": "Parse or null",
4232+ "symbol": "rush",
4233+ "usage": "stdlib",
4234+ "link": "https://urbit.org/docs/reference/library/4g/#rush",
4235+ "desc": "Used in the Hoon standard library."
4236+ }, {
4237+ "name": "Parse tape or null",
4238+ "symbol": "rust",
4239+ "usage": "stdlib",
4240+ "link": "https://urbit.org/docs/reference/library/4g/#rust",
4241+ "desc": "Used in the Hoon standard library."
4242+ }, {
4243+ "name": "Transform nodes (map)",
4244+ "symbol": "rut:by",
4245+ "usage": "stdlib",
4246+ "link": "https://urbit.org/docs/reference/library/2i/#rut-by",
4247+ "desc": "Used in the Hoon standard library."
4248+ }, {
4249+ "name": "(Undocumented)",
4250+ "symbol": "ruv:at",
4251+ "usage": "stdlib",
4252+ "link": "https://urbit.org/docs/reference/library/4b/#ruv-at",
4253+ "desc": "Used in the Hoon standard library."
4254+ }, {
4255+ "name": "(Undocumented)",
4256+ "symbol": "rux:at",
4257+ "usage": "stdlib",
4258+ "link": "https://urbit.org/docs/reference/library/4b/#rux-at",
4259+ "desc": "Used in the Hoon standard library."
4260+ }, {
4261+ "name": "Reverse Feistel-like cipher",
4262+ "symbol": "rynd:ob",
4263+ "usage": "stdlib",
4264+ "link": "https://urbit.org/docs/reference/library/3f/#rynd-ob",
4265+ "desc": "Used in the Hoon standard library."
4266+ }, {
4267+ "name": "Identity (produces same value)",
4268+ "symbol": "same",
4269+ "usage": "stdlib",
4270+ "link": "https://urbit.org/docs/reference/library/2n/#same",
4271+ "desc": "Used in the Hoon standard library."
4272+ }, {
4273+ "name": "Signed integer to @r",
4274+ "symbol": "san:ff",
4275+ "usage": "stdlib",
4276+ "link": "https://urbit.org/docs/reference/library/3b/#san-ff",
4277+ "desc": "Used in the Hoon standard library."
4278+ }, {
4279+ "name": "Signed integer to float",
4280+ "symbol": "san:fl",
4281+ "usage": "stdlib",
4282+ "link": "https://urbit.org/docs/reference/library/3b/#san-fl",
4283+ "desc": "Used in the Hoon standard library."
4284+ }, {
4285+ "name": "Unsigned integer to @rd",
4286+ "symbol": "san:rd",
4287+ "usage": "stdlib",
4288+ "link": "https://urbit.org/docs/reference/library/3b/#san-rd",
4289+ "desc": "Used in the Hoon standard library."
4290+ }, {
4291+ "name": "Signed integer to @rh",
4292+ "symbol": "san:rh",
4293+ "usage": "stdlib",
4294+ "link": "https://urbit.org/docs/reference/library/3b/#san-rh",
4295+ "desc": "Used in the Hoon standard library."
4296+ }, {
4297+ "name": "Signed integer to @rs",
4298+ "symbol": "san:rs",
4299+ "usage": "stdlib",
4300+ "link": "https://urbit.org/docs/reference/library/3b/#san-rs",
4301+ "desc": "Used in the Hoon standard library."
4302+ }, {
4303+ "name": "Signed integer to @rq",
4304+ "symbol": "san:rq",
4305+ "usage": "stdlib",
4306+ "link": "https://urbit.org/docs/reference/library/3b/#san-rq",
4307+ "desc": "Used in the Hoon standard library."
4308+ }, {
4309+ "name": "Soft-cast by odor",
4310+ "symbol": "sand",
4311+ "usage": "stdlib",
4312+ "link": "https://urbit.org/docs/reference/library/4b/#sand",
4313+ "desc": "Used in the Hoon standard library."
4314+ }, {
4315+ "name": "Check odor validity",
4316+ "symbol": "sane",
4317+ "usage": "stdlib",
4318+ "link": "https://urbit.org/docs/reference/library/4b/#sane",
4319+ "desc": "Used in the Hoon standard library."
4320+ }, {
4321+ "name": "Sign bit",
4322+ "symbol": "sb:ff",
4323+ "usage": "stdlib",
4324+ "link": "https://urbit.org/docs/reference/library/3b/#sb-ff",
4325+ "desc": "Used in the Hoon standard library."
4326+ }, {
4327+ "name": "Prefix (produce front of list)",
4328+ "symbol": "scag",
4329+ "usage": "stdlib",
4330+ "link": "https://urbit.org/docs/reference/library/2b/#scag",
4331+ "desc": "Used in the Hoon standard library."
4332+ }, {
4333+ "name": "Parse tape or crash",
4334+ "symbol": "scan",
4335+ "usage": "stdlib",
4336+ "link": "https://urbit.org/docs/reference/library/4g/#scan",
4337+ "desc": "Used in the Hoon standard library."
4338+ }, {
4339+ "name": "Render dime as cord",
4340+ "symbol": "scot",
4341+ "usage": "stdlib",
4342+ "link": "https://urbit.org/docs/reference/library/4m/#scot",
4343+ "desc": "Used in the Hoon standard library."
4344+ }, {
4345+ "name": "Render dime as tape",
4346+ "symbol": "scow",
4347+ "usage": "stdlib",
4348+ "link": "https://urbit.org/docs/reference/library/4m/#scow",
4349+ "desc": "Used in the Hoon standard library."
4350+ }, {
4351+ "name": "Convert from IEEE float to fn",
4352+ "symbol": "sea:ff",
4353+ "usage": "stdlib",
4354+ "link": "https://urbit.org/docs/reference/library/3b/#sea-ff",
4355+ "desc": "Used in the Hoon standard library."
4356+ }, {
4357+ "name": "Convert from double-precision binary float to fn",
4358+ "symbol": "sea:rd",
4359+ "usage": "stdlib",
4360+ "link": "https://urbit.org/docs/reference/library/3b/#sea-rd",
4361+ "desc": "Used in the Hoon standard library."
4362+ }, {
4363+ "name": "Convert from half-precision float to fn",
4364+ "symbol": "sea:rh",
4365+ "usage": "stdlib",
4366+ "link": "https://urbit.org/docs/reference/library/3b/#sea-rh",
4367+ "desc": "Used in the Hoon standard library."
4368+ }, {
4369+ "name": "Convert from single-precision float to fn",
4370+ "symbol": "sea:rs",
4371+ "usage": "stdlib",
4372+ "link": "https://urbit.org/docs/reference/library/3b/#sea-rs",
4373+ "desc": "Used in the Hoon standard library."
4374+ }, {
4375+ "name": "Convert from quad-precision float to fn",
4376+ "symbol": "sea:rq",
4377+ "usage": "stdlib",
4378+ "link": "https://urbit.org/docs/reference/library/3b/#sea-rq",
4379+ "desc": "Used in the Hoon standard library."
4380+ }, {
4381+ "name": "Conditional cook",
4382+ "symbol": "sear",
4383+ "usage": "stdlib",
4384+ "link": "https://urbit.org/docs/reference/library/4f/#sear",
4385+ "desc": "Used in the Hoon standard library."
4386+ }, {
4387+ "name": "Parse 1",
4388+ "symbol": "seb:ab",
4389+ "usage": "stdlib",
4390+ "link": "https://urbit.org/docs/reference/library/4j/#seb-ab",
4391+ "desc": "Used in the Hoon standard library."
4392+ }, {
4393+ "name": "Parse non-zero decimal digit",
4394+ "symbol": "sed:ab",
4395+ "usage": "stdlib",
4396+ "link": "https://urbit.org/docs/reference/library/4j/#sed-ab",
4397+ "desc": "Used in the Hoon standard library."
4398+ }, {
4399+ "name": "Parse [ (sel)",
4400+ "symbol": "sel",
4401+ "usage": "stdlib",
4402+ "link": "https://urbit.org/docs/reference/library/4h/#sel",
4403+ "desc": "Used in the Hoon standard library."
4404+ }, {
4405+ "name": "Parse ; (sem)",
4406+ "symbol": "sem",
4407+ "usage": "stdlib",
4408+ "link": "https://urbit.org/docs/reference/library/4h/#sem",
4409+ "desc": "Used in the Hoon standard library."
4410+ }, {
4411+ "name": "Parse ] (ser)",
4412+ "symbol": "ser",
4413+ "usage": "stdlib",
4414+ "link": "https://urbit.org/docs/reference/library/4h/#ser",
4415+ "desc": "Used in the Hoon standard library."
4416+ }, {
4417+ "name": "Mold generator (set)",
4418+ "symbol": "set",
4419+ "usage": "stdlib",
4420+ "link": "https://urbit.org/docs/reference/library/2o/#set",
4421+ "desc": "Used in the Hoon standard library."
4422+ }, {
4423+ "name": "Parse non-zero base 32 digit",
4424+ "symbol": "sev:ab",
4425+ "usage": "stdlib",
4426+ "link": "https://urbit.org/docs/reference/library/4j/#sev-ab",
4427+ "desc": "Used in the Hoon standard library."
4428+ }, {
4429+ "name": "Parse non-zero base 64 digit",
4430+ "symbol": "sew:ab",
4431+ "usage": "stdlib",
4432+ "link": "https://urbit.org/docs/reference/library/4j/#sew-ab",
4433+ "desc": "Used in the Hoon standard library."
4434+ }, {
4435+ "name": "Parse nonzero hexadecimal digit",
4436+ "symbol": "sex:ab",
4437+ "usage": "stdlib",
4438+ "link": "https://urbit.org/docs/reference/library/4j/#sex-ab",
4439+ "desc": "Used in the Hoon standard library."
4440+ }, {
4441+ "name": "Discard second rule",
4442+ "symbol": "sfix",
4443+ "usage": "stdlib",
4444+ "link": "https://urbit.org/docs/reference/library/4e/#sfix",
4445+ "desc": "Used in the Hoon standard library."
4446+ }, {
4447+ "name": "Double SHA-256",
4448+ "symbol": "shad",
4449+ "usage": "stdlib",
4450+ "link": "https://urbit.org/docs/reference/library/3d/#shad",
4451+ "desc": "Used in the Hoon standard library."
4452+ }, {
4453+ "name": "Half SHA-256",
4454+ "symbol": "shaf",
4455+ "usage": "stdlib",
4456+ "link": "https://urbit.org/docs/reference/library/3d/#shaf",
4457+ "desc": "Used in the Hoon standard library."
4458+ }, {
4459+ "name": "SHA-512 with length",
4460+ "symbol": "shal",
4461+ "usage": "stdlib",
4462+ "link": "https://urbit.org/docs/reference/library/3d/#shal",
4463+ "desc": "Used in the Hoon standard library."
4464+ }, {
4465+ "name": "128-bit noun hash",
4466+ "symbol": "sham",
4467+ "usage": "stdlib",
4468+ "link": "https://urbit.org/docs/reference/library/3d/#sham",
4469+ "desc": "Used in the Hoon standard library."
4470+ }, {
4471+ "name": "SHA-1",
4472+ "symbol": "shan",
4473+ "usage": "stdlib",
4474+ "link": "https://urbit.org/docs/reference/library/3d/#shan",
4475+ "desc": "Used in the Hoon standard library."
4476+ }, {
4477+ "name": "Salted hash",
4478+ "symbol": "shas",
4479+ "usage": "stdlib",
4480+ "link": "https://urbit.org/docs/reference/library/3d/#shas",
4481+ "desc": "Used in the Hoon standard library."
4482+ }, {
4483+ "name": "Hash to nbits",
4484+ "symbol": "shaw",
4485+ "usage": "stdlib",
4486+ "link": "https://urbit.org/docs/reference/library/3d/#shaw",
4487+ "desc": "Used in the Hoon standard library."
4488+ }, {
4489+ "name": "SHA-256",
4490+ "symbol": "shax",
4491+ "usage": "stdlib",
4492+ "link": "https://urbit.org/docs/reference/library/3d/#shax",
4493+ "desc": "Used in the Hoon standard library."
4494+ }, {
4495+ "name": "SHA-256 with length",
4496+ "symbol": "shay",
4497+ "usage": "stdlib",
4498+ "link": "https://urbit.org/docs/reference/library/3d/#shay",
4499+ "desc": "Used in the Hoon standard library."
4500+ }, {
4501+ "name": "SHA-512",
4502+ "symbol": "shaz",
4503+ "usage": "stdlib",
4504+ "link": "https://urbit.org/docs/reference/library/3d/#shaz",
4505+ "desc": "Used in the Hoon standard library."
4506+ }, {
4507+ "name": "(Undocumented)",
4508+ "symbol": "shep",
4509+ "usage": "stdlib",
4510+ "link": "https://urbit.org/docs/reference/library/4c/#shep",
4511+ "desc": "Used in the Hoon standard library."
4512+ }, {
4513+ "name": "Shift power",
4514+ "symbol": "shf:fl",
4515+ "usage": "stdlib",
4516+ "link": "https://urbit.org/docs/reference/library/3b/#shf-fl",
4517+ "desc": "Used in the Hoon standard library."
4518+ }, {
4519+ "name": "Match character within range",
4520+ "symbol": "shim",
4521+ "usage": "stdlib",
4522+ "link": "https://urbit.org/docs/reference/library/4f/#shim",
4523+ "desc": "Used in the Hoon standard library."
4524+ }, {
4525+ "name": "(Undocumented)",
4526+ "symbol": "shop",
4527+ "usage": "stdlib",
4528+ "link": "https://urbit.org/docs/reference/library/4c/#shop",
4529+ "desc": "Used in the Hoon standard library."
4530+ }, {
4531+ "name": "(Undocumented)",
4532+ "symbol": "show",
4533+ "usage": "stdlib",
4534+ "link": "https://urbit.org/docs/reference/library/4c/#show",
4535+ "desc": "Used in the Hoon standard library."
4536+ }, {
4537+ "name": "Signed integer",
4538+ "symbol": "si",
4539+ "usage": "stdlib",
4540+ "link": "https://urbit.org/docs/reference/library/3a/#si",
4541+ "desc": "Used in the Hoon standard library."
4542+ }, {
4543+ "name": "Construct set from null-terminated noun",
4544+ "symbol": "si:nl",
4545+ "usage": "stdlib",
4546+ "link": "https://urbit.org/docs/reference/library/2m/#si-nl",
4547+ "desc": "Used in the Hoon standard library."
4548+ }, {
4549+ "name": "Parse binary digit",
4550+ "symbol": "sib:ab",
4551+ "usage": "stdlib",
4552+ "link": "https://urbit.org/docs/reference/library/4j/#sib-ab",
4553+ "desc": "Used in the Hoon standard library."
4554+ }, {
4555+ "name": "Parse decimal digit",
4556+ "symbol": "sid:ab",
4557+ "usage": "stdlib",
4558+ "link": "https://urbit.org/docs/reference/library/4j/#sid-ab",
4559+ "desc": "Used in the Hoon standard library."
4560+ }, {
4561+ "name": "Parse ~ (sig)",
4562+ "symbol": "sig",
4563+ "usage": "stdlib",
4564+ "link": "https://urbit.org/docs/reference/library/4h/#sig",
4565+ "desc": "Used in the Hoon standard library."
4566+ }, {
4567+ "name": "Produce sign of IEEE float",
4568+ "symbol": "sig:ff",
4569+ "usage": "stdlib",
4570+ "link": "https://urbit.org/docs/reference/library/3b/#sig-ff",
4571+ "desc": "Used in the Hoon standard library."
4572+ }, {
4573+ "name": "Produce sign of @rd",
4574+ "symbol": "sig:rd",
4575+ "usage": "stdlib",
4576+ "link": "https://urbit.org/docs/reference/library/3b/#sig-rd",
4577+ "desc": "Used in the Hoon standard library."
4578+ }, {
4579+ "name": "Produce sign of half-precision float",
4580+ "symbol": "sig:rh",
4581+ "usage": "stdlib",
4582+ "link": "https://urbit.org/docs/reference/library/3b/#sig-rh",
4583+ "desc": "Used in the Hoon standard library."
4584+ }, {
4585+ "name": "Produce sign of @rs",
4586+ "symbol": "sig:rs",
4587+ "usage": "stdlib",
4588+ "link": "https://urbit.org/docs/reference/library/3b/#sig-rs",
4589+ "desc": "Used in the Hoon standard library."
4590+ }, {
4591+ "name": "Produce sign of quad-precision float",
4592+ "symbol": "sig:rq",
4593+ "usage": "stdlib",
4594+ "link": "https://urbit.org/docs/reference/library/3b/#sig-rq",
4595+ "desc": "Used in the Hoon standard library."
4596+ }, {
4597+ "name": "Produce set from list",
4598+ "symbol": "silt",
4599+ "usage": "stdlib",
4600+ "link": "https://urbit.org/docs/reference/library/2l/#silt",
4601+ "desc": "Used in the Hoon standard library."
4602+ }, {
4603+ "name": "First and second",
4604+ "symbol": "simu",
4605+ "usage": "stdlib",
4606+ "link": "https://urbit.org/docs/reference/library/4e/#simu",
4607+ "desc": "Used in the Hoon standard library."
4608+ }, {
4609+ "name": "Enforce modulo",
4610+ "symbol": "sit:fe",
4611+ "usage": "stdlib",
4612+ "link": "https://urbit.org/docs/reference/library/2c/#sit-fe",
4613+ "desc": "Used in the Hoon standard library."
4614+ }, {
4615+ "name": "Produce remainder of b modulo a",
4616+ "symbol": "sit:fo",
4617+ "usage": "stdlib",
4618+ "link": "https://urbit.org/docs/reference/library/3a/#sit-fo",
4619+ "desc": "Used in the Hoon standard library."
4620+ }, {
4621+ "name": "Parse a base 32 digit",
4622+ "symbol": "siv:ab",
4623+ "usage": "stdlib",
4624+ "link": "https://urbit.org/docs/reference/library/4j/#siv-ab",
4625+ "desc": "Used in the Hoon standard library."
4626+ }, {
4627+ "name": "Parse a base 64 digit",
4628+ "symbol": "siw:ab",
4629+ "usage": "stdlib",
4630+ "link": "https://urbit.org/docs/reference/library/4j/#siw-ab",
4631+ "desc": "Used in the Hoon standard library."
4632+ }, {
4633+ "name": "Parse a hexadecimal digit",
4634+ "symbol": "six:ab",
4635+ "usage": "stdlib",
4636+ "link": "https://urbit.org/docs/reference/library/4j/#six-ab",
4637+ "desc": "Used in the Hoon standard library."
4638+ }, {
4639+ "name": "Separate list into two lists from slammed elments",
4640+ "symbol": "skid",
4641+ "usage": "stdlib",
4642+ "link": "https://urbit.org/docs/reference/library/2b/#skid",
4643+ "desc": "Used in the Hoon standard library."
4644+ }, {
4645+ "name": "Produce list of elements from boolean gate",
4646+ "symbol": "skim",
4647+ "usage": "stdlib",
4648+ "link": "https://urbit.org/docs/reference/library/2b/#skim",
4649+ "desc": "Used in the Hoon standard library."
4650+ }, {
4651+ "name": "Produce list of elements failing boolean gate",
4652+ "symbol": "skip",
4653+ "usage": "stdlib",
4654+ "link": "https://urbit.org/docs/reference/library/2b/#skip",
4655+ "desc": "Used in the Hoon standard library."
4656+ }, {
4657+ "name": "Produce all elements from index in list",
4658+ "symbol": "slag",
4659+ "usage": "stdlib",
4660+ "link": "https://urbit.org/docs/reference/library/2b/#slag",
4661+ "desc": "Used in the Hoon standard library."
4662+ }, {
4663+ "name": "Curried slaw",
4664+ "symbol": "slat",
4665+ "usage": "stdlib",
4666+ "link": "https://urbit.org/docs/reference/library/4m/#slat",
4667+ "desc": "Used in the Hoon standard library."
4668+ }, {
4669+ "name": "Demand: parse cord with input odor",
4670+ "symbol": "slav",
4671+ "usage": "stdlib",
4672+ "link": "https://urbit.org/docs/reference/library/4m/#slav",
4673+ "desc": "Used in the Hoon standard library."
4674+ }, {
4675+ "name": "Parse cord to input odor",
4676+ "symbol": "slaw",
4677+ "usage": "stdlib",
4678+ "link": "https://urbit.org/docs/reference/library/4m/#slaw",
4679+ "desc": "Used in the Hoon standard library."
4680+ }, {
4681+ "name": "Parse cord to coin",
4682+ "symbol": "slay",
4683+ "usage": "stdlib",
4684+ "link": "https://urbit.org/docs/reference/library/4m/#slay",
4685+ "desc": "Used in the Hoon standard library."
4686+ }, {
4687+ "name": "Deify printf",
4688+ "symbol": "slog",
4689+ "usage": "stdlib",
4690+ "link": "https://urbit.org/docs/reference/library/2n/#slog",
4691+ "desc": "Used in the Hoon standard library."
4692+ }, {
4693+ "name": "Use gate to parse delimited list",
4694+ "symbol": "slug",
4695+ "usage": "stdlib",
4696+ "link": "https://urbit.org/docs/reference/library/4f/#slug",
4697+ "desc": "Used in the Hoon standard library."
4698+ }, {
4699+ "name": "Render path as tank",
4700+ "symbol": "smyt",
4701+ "usage": "stdlib",
4702+ "link": "https://urbit.org/docs/reference/library/4m/#smyt",
4703+ "desc": "Used in the Hoon standard library."
4704+ }, {
4705+ "name": "Produce element at specific index (list)",
4706+ "symbol": "snag",
4707+ "usage": "stdlib",
4708+ "link": "https://urbit.org/docs/reference/library/2b/#snag",
4709+ "desc": "Used in the Hoon standard library."
4710+ }, {
4711+ "name": "Produce element from list at specific null-terminated noun",
4712+ "symbol": "snag:nl",
4713+ "usage": "stdlib",
4714+ "link": "https://urbit.org/docs/reference/library/2m/#snag-nl",
4715+ "desc": "Used in the Hoon standard library."
4716+ }, {
4717+ "name": "Append noun to list",
4718+ "symbol": "snoc",
4719+ "usage": "stdlib",
4720+ "link": "https://urbit.org/docs/reference/library/2b/#snoc",
4721+ "desc": "Used in the Hoon standard library."
4722+ }, {
4723+ "name": "Coin parser engine",
4724+ "symbol": "so",
4725+ "usage": "stdlib",
4726+ "link": "https://urbit.org/docs/reference/library/4l/#so",
4727+ "desc": "Used in the Hoon standard library."
4728+ }, {
4729+ "name": "Maybe remold",
4730+ "symbol": "soft",
4731+ "usage": "stdlib",
4732+ "link": "https://urbit.org/docs/reference/library/2n/#soft",
4733+ "desc": "Used in the Hoon standard library."
4734+ }, {
4735+ "name": "Wrap value in unit",
4736+ "symbol": "some",
4737+ "usage": "stdlib",
4738+ "link": "https://urbit.org/docs/reference/library/2a/#some",
4739+ "desc": "Used in the Hoon standard library."
4740+ }, {
4741+ "name": "Parse ' (soq)",
4742+ "symbol": "soq",
4743+ "usage": "stdlib",
4744+ "link": "https://urbit.org/docs/reference/library/4h/#soq",
4745+ "desc": "Used in the Hoon standard library."
4746+ }, {
4747+ "name": "Quicksort (list)",
4748+ "symbol": "sort",
4749+ "usage": "stdlib",
4750+ "link": "https://urbit.org/docs/reference/library/2b/#sort",
4751+ "desc": "Used in the Hoon standard library."
4752+ }, {
4753+ "name": "Parse base 32 letter",
4754+ "symbol": "sov:ab",
4755+ "usage": "stdlib",
4756+ "link": "https://urbit.org/docs/reference/library/4j/#sov-ab",
4757+ "desc": "Used in the Hoon standard library."
4758+ }, {
4759+ "name": "Parse base 64 letter/symbol",
4760+ "symbol": "sow:ab",
4761+ "usage": "stdlib",
4762+ "link": "https://urbit.org/docs/reference/library/4j/#sow-ab",
4763+ "desc": "Used in the Hoon standard library."
4764+ }, {
4765+ "name": "Parse hexadecimal letter",
4766+ "symbol": "sox:ab",
4767+ "usage": "stdlib",
4768+ "link": "https://urbit.org/docs/reference/library/4j/#sox-ab",
4769+ "desc": "Used in the Hoon standard library."
4770+ }, {
4771+ "name": "Parse triple single-quote",
4772+ "symbol": "soz",
4773+ "usage": "stdlib",
4774+ "link": "https://urbit.org/docs/reference/library/4i/#soz",
4775+ "desc": "Used in the Hoon standard library."
4776+ }, {
4777+ "name": "ASCII atom",
4778+ "symbol": "span",
4779+ "usage": "stdlib",
4780+ "link": "https://urbit.org/docs/reference/library/4o/#span",
4781+ "desc": "Used in the Hoon standard library."
4782+ }, {
4783+ "name": "Render path as cord",
4784+ "symbol": "spat",
4785+ "usage": "stdlib",
4786+ "link": "https://urbit.org/docs/reference/library/4m/#spat",
4787+ "desc": "Used in the Hoon standard library."
4788+ }, {
4789+ "name": "Produce smallest denormalized float",
4790+ "symbol": "spd:fl",
4791+ "usage": "stdlib",
4792+ "link": "https://urbit.org/docs/reference/library/3b/#spd-fl",
4793+ "desc": "Used in the Hoon standard library."
4794+ }, {
4795+ "name": "Gate to list (with state)",
4796+ "symbol": "spin",
4797+ "usage": "stdlib",
4798+ "link": "https://urbit.org/docs/reference/library/2b/#spin",
4799+ "desc": "Used in the Hoon standard library."
4800+ }, {
4801+ "name": "Produce smallest normal float",
4802+ "symbol": "spn:fl",
4803+ "usage": "stdlib",
4804+ "link": "https://urbit.org/docs/reference/library/3b/#spn-fl",
4805+ "desc": "Used in the Hoon standard library."
4806+ }, {
4807+ "name": "Stack trace line",
4808+ "symbol": "spot",
4809+ "usage": "stdlib",
4810+ "link": "https://urbit.org/docs/reference/library/3g/#spot",
4811+ "desc": "Used in the Hoon standard library."
4812+ }, {
4813+ "name": "Render path as tape",
4814+ "symbol": "spud",
4815+ "usage": "stdlib",
4816+ "link": "https://urbit.org/docs/reference/library/4m/#spud",
4817+ "desc": "Used in the Hoon standard library."
4818+ }, {
4819+ "name": "Gate to list (with state)",
4820+ "symbol": "spun",
4821+ "usage": "stdlib",
4822+ "link": "https://urbit.org/docs/reference/library/2b/#spun",
4823+ "desc": "Used in the Hoon standard library."
4824+ }, {
4825+ "name": "Compute square root with remainder",
4826+ "symbol": "sqt",
4827+ "usage": "stdlib",
4828+ "link": "https://urbit.org/docs/reference/library/2g/#sqt",
4829+ "desc": "Used in the Hoon standard library."
4830+ }, {
4831+ "name": "Produce square root of IEEE float",
4832+ "symbol": "sqt:ff",
4833+ "usage": "stdlib",
4834+ "link": "https://urbit.org/docs/reference/library/3b/#sqt-ff",
4835+ "desc": "Used in the Hoon standard library."
4836+ }, {
4837+ "name": "Produce square root from signed and unsigned integer cell",
4838+ "symbol": "sqt:fl",
4839+ "usage": "stdlib",
4840+ "link": "https://urbit.org/docs/reference/library/3b/#sqt-fl",
4841+ "desc": "Used in the Hoon standard library."
4842+ }, {
4843+ "name": "Produce square root of double-precision float",
4844+ "symbol": "sqt:rd",
4845+ "usage": "stdlib",
4846+ "link": "https://urbit.org/docs/reference/library/3b/#sqt-rd",
4847+ "desc": "Used in the Hoon standard library."
4848+ }, {
4849+ "name": "Produce square root of half-precision float",
4850+ "symbol": "sqt:rh",
4851+ "usage": "stdlib",
4852+ "link": "https://urbit.org/docs/reference/library/3b/#sqt-rh",
4853+ "desc": "Used in the Hoon standard library."
4854+ }, {
4855+ "name": "Produce square root of single-precision float",
4856+ "symbol": "sqt:rs",
4857+ "usage": "stdlib",
4858+ "link": "https://urbit.org/docs/reference/library/3b/#sqt-rs",
4859+ "desc": "Used in the Hoon standard library."
4860+ }, {
4861+ "name": "Produce square root of quad-precision float",
4862+ "symbol": "sqt:rq",
4863+ "usage": "stdlib",
4864+ "link": "https://urbit.org/docs/reference/library/3b/#sqt-rq",
4865+ "desc": "Used in the Hoon standard library."
4866+ }, {
4867+ "name": "Parse cord to path",
4868+ "symbol": "stab",
4869+ "usage": "stdlib",
4870+ "link": "https://urbit.org/docs/reference/library/4m/#stab",
4871+ "desc": "Used in the Hoon standard library."
4872+ }, {
4873+ "name": "Add label",
4874+ "symbol": "stag",
4875+ "usage": "stdlib",
4876+ "link": "https://urbit.org/docs/reference/library/4f/#stag",
4877+ "desc": "Used in the Hoon standard library."
4878+ }, {
4879+ "name": "Produce list of matches",
4880+ "symbol": "star",
4881+ "usage": "stdlib",
4882+ "link": "https://urbit.org/docs/reference/library/4f/#star",
4883+ "desc": "Used in the Hoon standard library."
4884+ }, {
4885+ "name": "Add faces to range-parser pairs in list",
4886+ "symbol": "stet",
4887+ "usage": "stdlib",
4888+ "link": "https://urbit.org/docs/reference/library/4f/#stet",
4889+ "desc": "Used in the Hoon standard library."
4890+ }, {
4891+ "name": "Switch by first",
4892+ "symbol": "stew",
4893+ "usage": "stdlib",
4894+ "link": "https://urbit.org/docs/reference/library/4f/#stew",
4895+ "desc": "Used in the Hoon standard library."
4896+ }, {
4897+ "name": "Parse repeatedly",
4898+ "symbol": "stir",
4899+ "usage": "stdlib",
4900+ "link": "https://urbit.org/docs/reference/library/4f/#stir",
4901+ "desc": "Used in the Hoon standard library."
4902+ }, {
4903+ "name": "Parse several times",
4904+ "symbol": "stun",
4905+ "usage": "stdlib",
4906+ "link": "https://urbit.org/docs/reference/library/4f/#stun",
4907+ "desc": "Used in the Hoon standard library."
4908+ }, {
4909+ "name": "Subtract",
4910+ "symbol": "sub",
4911+ "usage": "stdlib",
4912+ "link": "https://urbit.org/docs/reference/library/1a/#sub",
4913+ "desc": "Used in the Hoon standard library."
4914+ }, {
4915+ "name": "Subtract from IEEE float",
4916+ "symbol": "sub:ff",
4917+ "usage": "stdlib",
4918+ "link": "https://urbit.org/docs/reference/library/3b/#sub-ff",
4919+ "desc": "Used in the Hoon standard library."
4920+ }, {
4921+ "name": "Subtract from signed and unsigned integer cells",
4922+ "symbol": "sub:fl",
4923+ "usage": "stdlib",
4924+ "link": "https://urbit.org/docs/reference/library/3b/#sub-fl",
4925+ "desc": "Used in the Hoon standard library."
4926+ }, {
4927+ "name": "Subtract from double-precision float",
4928+ "symbol": "sub:rd",
4929+ "usage": "stdlib",
4930+ "link": "https://urbit.org/docs/reference/library/3b/#sub-rd",
4931+ "desc": "Used in the Hoon standard library."
4932+ }, {
4933+ "name": "Subtract from half-precision float",
4934+ "symbol": "sub:rh",
4935+ "usage": "stdlib",
4936+ "link": "https://urbit.org/docs/reference/library/3b/#sub-rh",
4937+ "desc": "Used in the Hoon standard library."
4938+ }, {
4939+ "name": "Subtract from single-precision float",
4940+ "symbol": "sub:rs",
4941+ "usage": "stdlib",
4942+ "link": "https://urbit.org/docs/reference/library/3b/#sub-rs",
4943+ "desc": "Used in the Hoon standard library."
4944+ }, {
4945+ "name": "Subtract from quad-precision float",
4946+ "symbol": "sub:rq",
4947+ "usage": "stdlib",
4948+ "link": "https://urbit.org/docs/reference/library/3b/#sub-rq",
4949+ "desc": "Used in the Hoon standard library."
4950+ }, {
4951+ "name": "Sum two numbers in modular field",
4952+ "symbol": "sum:fe",
4953+ "usage": "stdlib",
4954+ "link": "https://urbit.org/docs/reference/library/2c/#sum-fe",
4955+ "desc": "Used in the Hoon standard library."
4956+ }, {
4957+ "name": "Modular sum",
4958+ "symbol": "sum:fo",
4959+ "usage": "stdlib",
4960+ "link": "https://urbit.org/docs/reference/library/3a/#sum-fo",
4961+ "desc": "Used in the Hoon standard library."
4962+ }, {
4963+ "name": "Addition (signed integer)",
4964+ "symbol": "sum:si",
4965+ "usage": "stdlib",
4966+ "link": "https://urbit.org/docs/reference/library/3a/#sum-si",
4967+ "desc": "Used in the Hoon standard library."
4968+ }, {
4969+ "name": "Unsigned integer to IEEE float",
4970+ "symbol": "sun:ff",
4971+ "usage": "stdlib",
4972+ "link": "https://urbit.org/docs/reference/library/3b/#sun-ff",
4973+ "desc": "Used in the Hoon standard library."
4974+ }, {
4975+ "name": "Unsigned integer to float",
4976+ "symbol": "sun:fl",
4977+ "usage": "stdlib",
4978+ "link": "https://urbit.org/docs/reference/library/3b/#sun-fl",
4979+ "desc": "Used in the Hoon standard library."
4980+ }, {
4981+ "name": "Unsigned integer to double-precision float",
4982+ "symbol": "sun:rd",
4983+ "usage": "stdlib",
4984+ "link": "https://urbit.org/docs/reference/library/3b/#sun-rd",
4985+ "desc": "Used in the Hoon standard library."
4986+ }, {
4987+ "name": "Unsigned integer to half-precision float",
4988+ "symbol": "sun:rh",
4989+ "usage": "stdlib",
4990+ "link": "https://urbit.org/docs/reference/library/3b/#sun-rh",
4991+ "desc": "Used in the Hoon standard library."
4992+ }, {
4993+ "name": "Unsigned integer to single-precision float",
4994+ "symbol": "sun:rs",
4995+ "usage": "stdlib",
4996+ "link": "https://urbit.org/docs/reference/library/3b/#sun-rs",
4997+ "desc": "Used in the Hoon standard library."
4998+ }, {
4999+ "name": "Unsigned integer to quad-precision float",
5000+ "symbol": "sun:rq",
5001+ "usage": "stdlib",
5002+ "link": "https://urbit.org/docs/reference/library/3b/#sun-rq",
5003+ "desc": "Used in the Hoon standard library."
5004+ }, {
5005+ "name": "@u to @s",
5006+ "symbol": "sun:si",
5007+ "usage": "stdlib",
5008+ "link": "https://urbit.org/docs/reference/library/3a/#sun-si",
5009+ "desc": "Used in the Hoon standard library."
5010+ }, {
5011+ "name": "Infix (list)",
5012+ "symbol": "swag",
5013+ "usage": "stdlib",
5014+ "link": "https://urbit.org/docs/reference/library/2b/#swag",
5015+ "desc": "Used in the Hoon standard library."
5016+ }, {
5017+ "name": "Reverse block order",
5018+ "symbol": "swp",
5019+ "usage": "stdlib",
5020+ "link": "https://urbit.org/docs/reference/library/2c/#swp",
5021+ "desc": "Used in the Hoon standard library."
5022+ }, {
5023+ "name": "Switch rounding mode of floating point",
5024+ "symbol": "swr:fl",
5025+ "usage": "stdlib",
5026+ "link": "https://urbit.org/docs/reference/library/3b/#swr-fl",
5027+ "desc": "Used in the Hoon standard library."
5028+ }, {
5029+ "name": "Produce set from null-terminated noun",
5030+ "symbol": "sy",
5031+ "usage": "stdlib",
5032+ "link": "https://urbit.org/docs/reference/library/2m/#sy",
5033+ "desc": "Used in the Hoon standard library."
5034+ }, {
5035+ "name": "Term",
5036+ "symbol": "sym",
5037+ "usage": "stdlib",
5038+ "link": "https://urbit.org/docs/reference/library/4i/#sym",
5039+ "desc": "Used in the Hoon standard library."
5040+ }, {
5041+ "name": "Get sign",
5042+ "symbol": "syn:fl",
5043+ "usage": "stdlib",
5044+ "link": "https://urbit.org/docs/reference/library/3b/#syn-fl",
5045+ "desc": "Used in the Hoon standard library."
5046+ }, {
5047+ "name": "Sign test",
5048+ "symbol": "syn:si",
5049+ "usage": "stdlib",
5050+ "link": "https://urbit.org/docs/reference/library/3a/#syn-si",
5051+ "desc": "Used in the Hoon standard library."
5052+ }, {
5053+ "name": "Get tail of cell",
5054+ "symbol": "tail",
5055+ "usage": "stdlib",
5056+ "link": "https://urbit.org/docs/reference/library/2n/#tail",
5057+ "desc": "Used in the Hoon standard library."
5058+ }, {
5059+ "name": "Queue to list",
5060+ "symbol": "tap:to",
5061+ "usage": "stdlib",
5062+ "link": "https://urbit.org/docs/reference/library/2k/#tap-to",
5063+ "desc": "Used in the Hoon standard library."
5064+ }, {
5065+ "name": "Parse * (tar)",
5066+ "symbol": "tar",
5067+ "usage": "stdlib",
5068+ "link": "https://urbit.org/docs/reference/library/4h/#tar",
5069+ "desc": "Used in the Hoon standard library."
5070+ }, {
5071+ "name": "Generic print structure",
5072+ "symbol": "tang",
5073+ "usage": "stdlib",
5074+ "link": "https://urbit.org/docs/reference/library/2q/#tang",
5075+ "desc": "Used in the Hoon standard library."
5076+ }, {
5077+ "name": "Pretty-printing structure",
5078+ "symbol": "tank",
5079+ "usage": "stdlib",
5080+ "link": "https://urbit.org/docs/reference/library/2q/#tank",
5081+ "desc": "Used in the Hoon standard library."
5082+ }, {
5083+ "name": "Listify pairs",
5084+ "symbol": "tap:by",
5085+ "usage": "stdlib",
5086+ "link": "https://urbit.org/docs/reference/library/2i/#tap-by",
5087+ "desc": "Used in the Hoon standard library."
5088+ }, {
5089+ "name": "Flatten set into list",
5090+ "symbol": "tap:in",
5091+ "usage": "stdlib",
5092+ "link": "https://urbit.org/docs/reference/library/2h/#tap-in",
5093+ "desc": "Used in the Hoon standard library."
5094+ }, {
5095+ "name": "List of characters",
5096+ "symbol": "tape",
5097+ "usage": "stdlib",
5098+ "link": "https://urbit.org/docs/reference/library/2q/#tape",
5099+ "desc": "Used in the Hoon standard library."
5100+ }, {
5101+ "name": "Parsed time",
5102+ "symbol": "tarp",
5103+ "usage": "stdlib",
5104+ "link": "https://urbit.org/docs/reference/library/2q/#tarp",
5105+ "desc": "Used in the Hoon standard library."
5106+ }, {
5107+ "name": "Parse signed dime",
5108+ "symbol": "tash:so",
5109+ "usage": "stdlib",
5110+ "link": "https://urbit.org/docs/reference/library/4l/#tash-so",
5111+ "desc": "Used in the Hoon standard library."
5112+ }, {
5113+ "name": "Parse ` (tec)",
5114+ "symbol": "tec",
5115+ "usage": "stdlib",
5116+ "link": "https://urbit.org/docs/reference/library/4h/#tec",
5117+ "desc": "Used in the Hoon standard library."
5118+ }, {
5119+ "name": "Parse decimal number with <= 3 digits",
5120+ "symbol": "ted:ab",
5121+ "usage": "stdlib",
5122+ "link": "https://urbit.org/docs/reference/library/4j/#ted-ab",
5123+ "desc": "Used in the Hoon standard library."
5124+ }, {
5125+ "name": "UTF-8 length",
5126+ "symbol": "teff",
5127+ "usage": "stdlib",
5128+ "link": "https://urbit.org/docs/reference/library/4b/#teff",
5129+ "desc": "Used in the Hoon standard library."
5130+ }, {
5131+ "name": "Reverse Feistel-like cipher",
5132+ "symbol": "teil:ob",
5133+ "usage": "stdlib",
5134+ "link": "https://urbit.org/docs/reference/library/3f/#teil-ob",
5135+ "desc": "Used in the Hoon standard library."
5136+ }, {
5137+ "name": "Hoon constant",
5138+ "symbol": "term",
5139+ "usage": "stdlib",
5140+ "link": "https://urbit.org/docs/reference/library/2q/#term",
5141+ "desc": "Used in the Hoon standard library."
5142+ }, {
5143+ "name": "Test for equality",
5144+ "symbol": "test",
5145+ "usage": "stdlib",
5146+ "link": "https://urbit.org/docs/reference/library/2n/#test",
5147+ "desc": "Used in the Hoon standard library."
5148+ }, {
5149+ "name": "Parse 3 decimal digits",
5150+ "symbol": "tid:ab",
5151+ "usage": "stdlib",
5152+ "link": "https://urbit.org/docs/reference/library/4j/#tid-ab",
5153+ "desc": "Used in the Hoon standard library."
5154+ }, {
5155+ "name": "(Undocumented)",
5156+ "symbol": "tiki",
5157+ "usage": "stdlib",
5158+ "link": "https://urbit.org/docs/reference/library/4o/#tiki",
5159+ "desc": "Used in the Hoon standard library."
5160+ }, {
5161+ "name": "Parse 3 lowercase letters",
5162+ "symbol": "til:ab",
5163+ "usage": "stdlib",
5164+ "link": "https://urbit.org/docs/reference/library/4j/#til-ab",
5165+ "desc": "Used in the Hoon standard library."
5166+ }, {
5167+ "name": "Leading phonetic byte",
5168+ "symbol": "tip:ab",
5169+ "usage": "stdlib",
5170+ "link": "https://urbit.org/docs/reference/library/4j/#tip-ab",
5171+ "desc": "Used in the Hoon standard library."
5172+ }, {
5173+ "name": "Trailing phonetic syllable",
5174+ "symbol": "tiq:ab",
5175+ "usage": "stdlib",
5176+ "link": "https://urbit.org/docs/reference/library/4j/#tiq-ab",
5177+ "desc": "Used in the Hoon standard library."
5178+ }, {
5179+ "name": "Parse = (tis)",
5180+ "symbol": "tis",
5181+ "usage": "stdlib",
5182+ "link": "https://urbit.org/docs/reference/library/4h/#tis",
5183+ "desc": "Used in the Hoon standard library."
5184+ }, {
5185+ "name": "Queue operations",
5186+ "symbol": "to",
5187+ "usage": "stdlib",
5188+ "link": "https://urbit.org/docs/reference/library/2k/#to",
5189+ "desc": "Used in the Hoon standard library."
5190+ }, {
5191+ "name": "Fetch suffix",
5192+ "symbol": "tod:po",
5193+ "usage": "stdlib",
5194+ "link": "https://urbit.org/docs/reference/library/4a/#tod-po",
5195+ "desc": "Used in the Hoon standard library."
5196+ }, {
5197+ "name": "Tree of faces",
5198+ "symbol": "toga",
5199+ "usage": "stdlib",
5200+ "link": "https://urbit.org/docs/reference/library/4o/#toga",
5201+ "desc": "Used in the Hoon standard library."
5202+ }, {
5203+ "name": "Round IEEE float to nearest signed integer",
5204+ "symbol": "toi:ff",
5205+ "usage": "stdlib",
5206+ "link": "https://urbit.org/docs/reference/library/3b/#toi-ff",
5207+ "desc": "Used in the Hoon standard library."
5208+ }, {
5209+ "name": "Round float to nearest signed integer",
5210+ "symbol": "toi:fl",
5211+ "usage": "stdlib",
5212+ "link": "https://urbit.org/docs/reference/library/3b/#toi-fl",
5213+ "desc": "Used in the Hoon standard library."
5214+ }, {
5215+ "name": "Round double-precision float to nearest signed integer",
5216+ "symbol": "toi:rd",
5217+ "usage": "stdlib",
5218+ "link": "https://urbit.org/docs/reference/library/3b/#toi-rd",
5219+ "desc": "Used in the Hoon standard library."
5220+ }, {
5221+ "name": "Round half-precision float to nearest signed integer",
5222+ "symbol": "toi:rh",
5223+ "usage": "stdlib",
5224+ "link": "https://urbit.org/docs/reference/library/3b/#toi-rh",
5225+ "desc": "Used in the Hoon standard library."
5226+ }, {
5227+ "name": "Round single-precision float to nearest signed integer",
5228+ "symbol": "toi:rs",
5229+ "usage": "stdlib",
5230+ "link": "https://urbit.org/docs/reference/library/3b/#toi-rs",
5231+ "desc": "Used in the Hoon standard library."
5232+ }, {
5233+ "name": "Round quad-precision float to nearest signed integer",
5234+ "symbol": "toi:rq",
5235+ "usage": "stdlib",
5236+ "link": "https://urbit.org/docs/reference/library/3b/#toi-rq",
5237+ "desc": "Used in the Hoon standard library."
5238+ }, {
5239+ "name": "Round unsigned and signed integer to float",
5240+ "symbol": "toj:fl",
5241+ "usage": "stdlib",
5242+ "link": "https://urbit.org/docs/reference/library/3b/#toj-fl",
5243+ "desc": "Used in the Hoon standard library."
5244+ }, {
5245+ "name": "Nock result (error report)",
5246+ "symbol": "tone",
5247+ "usage": "stdlib",
5248+ "link": "https://urbit.org/docs/reference/library/3g/#tone",
5249+ "desc": "Used in the Hoon standard library."
5250+ }, {
5251+ "name": "Nock result (stack trace)",
5252+ "symbol": "toon",
5253+ "usage": "stdlib",
5254+ "link": "https://urbit.org/docs/reference/library/3g/#toon",
5255+ "desc": "Used in the Hoon standard library."
5256+ }, {
5257+ "name": "Produce head of queue",
5258+ "symbol": "top:to",
5259+ "usage": "stdlib",
5260+ "link": "https://urbit.org/docs/reference/library/2k/#top-to",
5261+ "desc": "Used in the Hoon standard library."
5262+ }, {
5263+ "name": "Fetch prefix",
5264+ "symbol": "tos:po",
5265+ "usage": "stdlib",
5266+ "link": "https://urbit.org/docs/reference/library/4a/#tos-po",
5267+ "desc": "Used in the Hoon standard library."
5268+ }, {
5269+ "name": "Convert half-precision float to single-precision float",
5270+ "symbol": "tos:rh",
5271+ "usage": "stdlib",
5272+ "link": "https://urbit.org/docs/reference/library/3b/#tos-rh",
5273+ "desc": "Used in the Hoon standard library."
5274+ }, {
5275+ "name": "Core with one arm $",
5276+ "symbol": "trap",
5277+ "usage": "stdlib",
5278+ "link": "https://urbit.org/docs/reference/library/1c/#trap",
5279+ "desc": "Used in the Hoon standard library."
5280+ }, {
5281+ "name": "Mold generator (tree)",
5282+ "symbol": "tree",
5283+ "usage": "stdlib",
5284+ "link": "https://urbit.org/docs/reference/library/1c/#tree",
5285+ "desc": "Used in the Hoon standard library."
5286+ }, {
5287+ "name": "Mold generator (tuple of three types)",
5288+ "symbol": "trel",
5289+ "usage": "stdlib",
5290+ "link": "https://urbit.org/docs/reference/library/1c/#trel",
5291+ "desc": "Used in the Hoon standard library."
5292+ }, {
5293+ "name": "Tape split",
5294+ "symbol": "trim",
5295+ "usage": "stdlib",
5296+ "link": "https://urbit.org/docs/reference/library/4b/#trim",
5297+ "desc": "Used in the Hoon standard library."
5298+ }, {
5299+ "name": "Cord to tape",
5300+ "symbol": "trip",
5301+ "usage": "stdlib",
5302+ "link": "https://urbit.org/docs/reference/library/4b/#trip",
5303+ "desc": "Used in the Hoon standard library."
5304+ }, {
5305+ "name": "UTF-8 to UTF-32 tape",
5306+ "symbol": "tuba",
5307+ "usage": "stdlib",
5308+ "link": "https://urbit.org/docs/reference/library/4b/#tuba",
5309+ "desc": "Used in the Hoon standard library."
5310+ }, {
5311+ "name": "UTF-32 to UTF-8 tape",
5312+ "symbol": "tufa",
5313+ "usage": "stdlib",
5314+ "link": "https://urbit.org/docs/reference/library/4b/#tufa",
5315+ "desc": "Used in the Hoon standard library."
5316+ }, {
5317+ "name": "XML template tree",
5318+ "symbol": "tuna",
5319+ "usage": "stdlib",
5320+ "link": "https://urbit.org/docs/reference/library/4o/#tuna",
5321+ "desc": "Used in the Hoon standard library."
5322+ }, {
5323+ "name": "UTF-32 to UTF-8 text",
5324+ "symbol": "tuft",
5325+ "usage": "stdlib",
5326+ "link": "https://urbit.org/docs/reference/library/4b/#tuft",
5327+ "desc": "Used in the Hoon standard library."
5328+ }, {
5329+ "name": "UTF-8 to UTF-32 cord",
5330+ "symbol": "turf",
5331+ "usage": "stdlib",
5332+ "link": "https://urbit.org/docs/reference/library/4b/#turf",
5333+ "desc": "Used in the Hoon standard library."
5334+ }, {
5335+ "name": "Gate to list",
5336+ "symbol": "turn",
5337+ "usage": "stdlib",
5338+ "link": "https://urbit.org/docs/reference/library/2b/#turn",
5339+ "desc": "Used in the Hoon standard library."
5340+ }, {
5341+ "name": "List of expressions",
5342+ "symbol": "tusk",
5343+ "usage": "stdlib",
5344+ "link": "https://urbit.org/docs/reference/library/4o/#tusk",
5345+ "desc": "Used in the Hoon standard library."
5346+ }, {
5347+ "name": "Parse coins without ~ prefix",
5348+ "symbol": "twid:so",
5349+ "usage": "stdlib",
5350+ "link": "https://urbit.org/docs/reference/library/4l/#twid-so",
5351+ "desc": "Used in the Hoon standard library."
5352+ }, {
5353+ "name": "List of 'maybe' hoons",
5354+ "symbol": "tyke",
5355+ "usage": "stdlib",
5356+ "link": "https://urbit.org/docs/reference/library/4o/#tyke",
5357+ "desc": "Used in the Hoon standard library."
5358+ }, {
5359+ "name": "Pointer for type",
5360+ "symbol": "typo",
5361+ "usage": "stdlib",
5362+ "link": "https://urbit.org/docs/reference/library/4o/#typo",
5363+ "desc": "Used in the Hoon standard library."
5364+ }, {
5365+ "name": "List, term hoon",
5366+ "symbol": "tyre",
5367+ "usage": "stdlib",
5368+ "link": "https://urbit.org/docs/reference/library/4o/#tyre",
5369+ "desc": "Used in the Hoon standard library."
5370+ }, {
5371+ "name": "Reversible scrambling",
5372+ "symbol": "un",
5373+ "usage": "stdlib",
5374+ "link": "https://urbit.org/docs/reference/library/3f/#un",
5375+ "desc": "Used in the Hoon standard library."
5376+ }, {
5377+ "name": "Union (map between keys of two lists)",
5378+ "symbol": "uni:by",
5379+ "usage": "stdlib",
5380+ "link": "https://urbit.org/docs/reference/library/2i/#uni-by",
5381+ "desc": "Used in the Hoon standard library."
5382+ }, {
5383+ "name": "Change representation to odd",
5384+ "symbol": "uni:fl",
5385+ "usage": "stdlib",
5386+ "link": "https://urbit.org/docs/reference/library/3b/#uni-fl",
5387+ "desc": "Used in the Hoon standard library."
5388+ }, {
5389+ "name": "Union (sets)",
5390+ "symbol": "uni:in",
5391+ "usage": "stdlib",
5392+ "link": "https://urbit.org/docs/reference/library/2h/#uni-in",
5393+ "desc": "Used in the Hoon standard library."
5394+ }, {
5395+ "name": "Mold generator (maybe)",
5396+ "symbol": "unit",
5397+ "usage": "stdlib",
5398+ "link": "https://urbit.org/docs/reference/library/1c/#unit",
5399+ "desc": "Used in the Hoon standard library."
5400+ }, {
5401+ "name": "Turn (with key) (map)",
5402+ "symbol": "urn:by",
5403+ "usage": "stdlib",
5404+ "link": "https://urbit.org/docs/reference/library/2i/#urn-by",
5405+ "desc": "Used in the Hoon standard library."
5406+ }, {
5407+ "name": "Parse span characters",
5408+ "symbol": "urs:ab",
5409+ "usage": "stdlib",
5410+ "link": "https://urbit.org/docs/reference/library/4j/#urs-ab",
5411+ "desc": "Used in the Hoon standard library."
5412+ }, {
5413+ "name": "Parse non-_ span",
5414+ "symbol": "urt:ab",
5415+ "usage": "stdlib",
5416+ "link": "https://urbit.org/docs/reference/library/4j/#urt-ab",
5417+ "desc": "Used in the Hoon standard library."
5418+ }, {
5419+ "name": "Render base 32",
5420+ "symbol": "v:ne",
5421+ "usage": "stdlib",
5422+ "link": "https://urbit.org/docs/reference/library/4j/#v-ne",
5423+ "desc": "Used in the Hoon standard library."
5424+ }, {
5425+ "name": "Typed data",
5426+ "symbol": "vase",
5427+ "usage": "stdlib",
5428+ "link": "https://urbit.org/docs/reference/library/4o/#vase",
5429+ "desc": "Used in the Hoon standard library."
5430+ }, {
5431+ "name": "Axis syntax parser",
5432+ "symbol": "ven",
5433+ "usage": "stdlib",
5434+ "link": "https://urbit.org/docs/reference/library/4i/#ven",
5435+ "desc": "Used in the Hoon standard library."
5436+ }, {
5437+ "name": "Convert during reboot",
5438+ "symbol": "vise",
5439+ "usage": "stdlib",
5440+ "link": "https://urbit.org/docs/reference/library/4o/#vise",
5441+ "desc": "Used in the Hoon standard library."
5442+ }, {
5443+ "name": "Parse base 64 digit",
5444+ "symbol": "vit",
5445+ "usage": "stdlib",
5446+ "link": "https://urbit.org/docs/reference/library/4i/#vit",
5447+ "desc": "Used in the Hoon standard library."
5448+ }, {
5449+ "name": "Parse base 32 digit with dot separators",
5450+ "symbol": "viz:ag",
5451+ "usage": "stdlib",
5452+ "link": "https://urbit.org/docs/reference/library/4j/#viz-ag",
5453+ "desc": "Used in the Hoon standard library."
5454+ }, {
5455+ "name": "Vertical order",
5456+ "symbol": "vor",
5457+ "usage": "stdlib",
5458+ "link": "https://urbit.org/docs/reference/library/2f/#vor",
5459+ "desc": "Used in the Hoon standard library."
5460+ }, {
5461+ "name": "Parse bas, soq, or bix",
5462+ "symbol": "voy:ab",
5463+ "usage": "stdlib",
5464+ "link": "https://urbit.org/docs/reference/library/4j/#voy-ab",
5465+ "desc": "Used in the Hoon standard library."
5466+ }, {
5467+ "name": "Comments to null",
5468+ "symbol": "vul",
5469+ "usage": "stdlib",
5470+ "link": "https://urbit.org/docs/reference/library/4i/#vul",
5471+ "desc": "Used in the Hoon standard library."
5472+ }, {
5473+ "name": "Parse base 32 string",
5474+ "symbol": "vum:ag",
5475+ "usage": "stdlib",
5476+ "link": "https://urbit.org/docs/reference/library/4j/#vum-ag",
5477+ "desc": "Used in the Hoon standard library."
5478+ }, {
5479+ "name": "Render base 64 digit",
5480+ "symbol": "w:ne",
5481+ "usage": "stdlib",
5482+ "link": "https://urbit.org/docs/reference/library/4j/#w-ne",
5483+ "desc": "Used in the Hoon standard library."
5484+ }, {
5485+ "name": "Coin format encode",
5486+ "symbol": "wack",
5487+ "usage": "stdlib",
5488+ "link": "https://urbit.org/docs/reference/library/4b/#wack",
5489+ "desc": "Used in the Hoon standard library."
5490+ }, {
5491+ "name": "List of cords",
5492+ "symbol": "wain",
5493+ "usage": "stdlib",
5494+ "link": "https://urbit.org/docs/reference/library/2q/#wain",
5495+ "desc": "Used in the Hoon standard library."
5496+ }, {
5497+ "name": "List of list of characters",
5498+ "symbol": "wall",
5499+ "usage": "stdlib",
5500+ "link": "https://urbit.org/docs/reference/library/2q/#wall",
5501+ "desc": "Used in the Hoon standard library."
5502+ }, {
5503+ "name": "Concatenate two lists",
5504+ "symbol": "weld",
5505+ "usage": "stdlib",
5506+ "link": "https://urbit.org/docs/reference/library/2b/#weld",
5507+ "desc": "Used in the Hoon standard library."
5508+ }, {
5509+ "name": "Concatenate null-terminated nouns",
5510+ "symbol": "weld:nl",
5511+ "usage": "stdlib",
5512+ "link": "https://urbit.org/docs/reference/library/2m/#weld-nl",
5513+ "desc": "Used in the Hoon standard library."
5514+ }, {
5515+ "name": "Perfect concatenate (lists)",
5516+ "symbol": "welp",
5517+ "usage": "stdlib",
5518+ "link": "https://urbit.org/docs/reference/library/2b/#welp",
5519+ "desc": "Used in the Hoon standard library."
5520+ }, {
5521+ "name": "Coin format decode",
5522+ "symbol": "wick",
5523+ "usage": "stdlib",
5524+ "link": "https://urbit.org/docs/reference/library/4b/#wick",
5525+ "desc": "Used in the Hoon standard library."
5526+ }, {
5527+ "name": "win - render tape",
5528+ "symbol": "wig:re",
5529+ "usage": "stdlib",
5530+ "link": "https://urbit.org/docs/reference/library/4c/#wig-re",
5531+ "desc": "Used in the Hoon standard library."
5532+ }, {
5533+ "name": "Render at indent",
5534+ "symbol": "win:re",
5535+ "usage": "stdlib",
5536+ "link": "https://urbit.org/docs/reference/library/4c/#win-re",
5537+ "desc": "Used in the Hoon standard library."
5538+ }, {
5539+ "name": "Address in subject",
5540+ "symbol": "wing",
5541+ "usage": "stdlib",
5542+ "link": "https://urbit.org/docs/reference/library/4o/#wing",
5543+ "desc": "Used in the Hoon standard library."
5544+ }, {
5545+ "name": "Parse base 64 number",
5546+ "symbol": "wiz:ag",
5547+ "usage": "stdlib",
5548+ "link": "https://urbit.org/docs/reference/library/4j/#wiz-ag",
5549+ "desc": "Used in the Hoon standard library."
5550+ }, {
5551+ "name": "Unescape cord",
5552+ "symbol": "woad",
5553+ "usage": "stdlib",
5554+ "link": "https://urbit.org/docs/reference/library/4b/#woad",
5555+ "desc": "Used in the Hoon standard library."
5556+ }, {
5557+ "name": "Escape cord",
5558+ "symbol": "wood",
5559+ "usage": "stdlib",
5560+ "link": "https://urbit.org/docs/reference/library/4b/#wood",
5561+ "desc": "Used in the Hoon standard library."
5562+ }, {
5563+ "name": "Product from edge",
5564+ "symbol": "wonk",
5565+ "usage": "stdlib",
5566+ "link": "https://urbit.org/docs/reference/library/3g/#wonk",
5567+ "desc": "Used in the Hoon standard library."
5568+ }, {
5569+ "name": "Restore structure",
5570+ "symbol": "wred:un",
5571+ "usage": "stdlib",
5572+ "link": "https://urbit.org/docs/reference/library/3f/#wred-un",
5573+ "desc": "Used in the Hoon standard library."
5574+ }, {
5575+ "name": "Conceal structure",
5576+ "symbol": "wren:un",
5577+ "usage": "stdlib",
5578+ "link": "https://urbit.org/docs/reference/library/3f/#wren-un",
5579+ "desc": "Used in the Hoon standard library."
5580+ }, {
5581+ "name": "Parse ? (wut)",
5582+ "symbol": "wut",
5583+ "usage": "stdlib",
5584+ "link": "https://urbit.org/docs/reference/library/4h/#wut",
5585+ "desc": "Used in the Hoon standard library."
5586+ }, {
5587+ "name": "Produce depth of tree map",
5588+ "symbol": "wyt:by",
5589+ "usage": "stdlib",
5590+ "link": "https://urbit.org/docs/reference/library/2i/#wyt-by",
5591+ "desc": "Used in the Hoon standard library."
5592+ }, {
5593+ "name": "Produce number of elements in set",
5594+ "symbol": "wyt:in",
5595+ "usage": "stdlib",
5596+ "link": "https://urbit.org/docs/reference/library/2h/#wyt-in",
5597+ "desc": "Used in the Hoon standard library."
5598+ }, {
5599+ "name": "Render hexadecimal digit as atom of ASCII byte value",
5600+ "symbol": "x:ne",
5601+ "usage": "stdlib",
5602+ "link": "https://urbit.org/docs/reference/library/4j/#x-ne",
5603+ "desc": "Used in the Hoon standard library."
5604+ }, {
5605+ "name": "Binary logarithm",
5606+ "symbol": "xeb",
5607+ "usage": "stdlib",
5608+ "link": "https://urbit.org/docs/reference/library/2c/#xeb",
5609+ "desc": "Used in the Hoon standard library."
5610+ }, {
5611+ "name": "Expand signed and unsigned integer cell",
5612+ "symbol": "xpd:fl",
5613+ "usage": "stdlib",
5614+ "link": "https://urbit.org/docs/reference/library/3b/#xpd-fl",
5615+ "desc": "Used in the Hoon standard library."
5616+ }, {
5617+ "name": "Time since beginning of time",
5618+ "symbol": "yall",
5619+ "usage": "stdlib",
5620+ "link": "https://urbit.org/docs/reference/library/3c/#yall",
5621+ "desc": "Used in the Hoon standard library."
5622+ }, {
5623+ "name": "Days since beginning of time",
5624+ "symbol": "yawn",
5625+ "usage": "stdlib",
5626+ "link": "https://urbit.org/docs/reference/library/3c/#yawn",
5627+ "desc": "Used in the Hoon standard library."
5628+ }, {
5629+ "name": "Date to @d",
5630+ "symbol": "year",
5631+ "usage": "stdlib",
5632+ "link": "https://urbit.org/docs/reference/library/3c/#year",
5633+ "desc": "Used in the Hoon standard library."
5634+ }, {
5635+ "name": "Tarp from atomic date",
5636+ "symbol": "yell",
5637+ "usage": "stdlib",
5638+ "link": "https://urbit.org/docs/reference/library/3c/#yell",
5639+ "desc": "Used in the Hoon standard library."
5640+ }, {
5641+ "name": "Determine if leap-week",
5642+ "symbol": "yelp",
5643+ "usage": "stdlib",
5644+ "link": "https://urbit.org/docs/reference/library/3c/#yelp",
5645+ "desc": "Used in the Hoon standard library."
5646+ }, {
5647+ "name": "Seconds in year",
5648+ "symbol": "yer:yo",
5649+ "usage": "stdlib",
5650+ "link": "https://urbit.org/docs/reference/library/3c/#yer-yo",
5651+ "desc": "Used in the Hoon standard library."
5652+ }, {
5653+ "name": "Time constants core",
5654+ "symbol": "yo",
5655+ "usage": "stdlib",
5656+ "link": "https://urbit.org/docs/reference/library/3c/#yo",
5657+ "desc": "Used in the Hoon standard library."
5658+ }, {
5659+ "name": "Date from atomic date",
5660+ "symbol": "yore",
5661+ "usage": "stdlib",
5662+ "link": "https://urbit.org/docs/reference/library/3c/#yore",
5663+ "desc": "Used in the Hoon standard library."
5664+ }, {
5665+ "name": "Daily time to time atom",
5666+ "symbol": "yule",
5667+ "usage": "stdlib",
5668+ "link": "https://urbit.org/docs/reference/library/3c/#yule",
5669+ "desc": "Used in the Hoon standard library."
5670+ }, {
5671+ "name": "Look up in 255 sub box",
5672+ "symbol": "zaft:un",
5673+ "usage": "stdlib",
5674+ "link": "https://urbit.org/docs/reference/library/3f/#zaft-un",
5675+ "desc": "Used in the Hoon standard library."
5676+ }, {
5677+ "name": "Add bottom into top",
5678+ "symbol": "zag:mu",
5679+ "usage": "stdlib",
5680+ "link": "https://urbit.org/docs/reference/library/4j/#zag-mu",
5681+ "desc": "Used in the Hoon standard library."
5682+ }, {
5683+ "name": "Parse ! (zap)",
5684+ "symbol": "zap",
5685+ "usage": "stdlib",
5686+ "link": "https://urbit.org/docs/reference/library/4h/#zap",
5687+ "desc": "Used in the Hoon standard library."
5688+ }, {
5689+ "name": "Reverse look up in 255 sub box",
5690+ "symbol": "zart:un",
5691+ "usage": "stdlib",
5692+ "link": "https://urbit.org/docs/reference/library/3f/#zart-un",
5693+ "desc": "Used in the Hoon standard library."
5694+ }, {
5695+ "name": "Produce zero as float",
5696+ "symbol": "zer:fl",
5697+ "usage": "stdlib",
5698+ "link": "https://urbit.org/docs/reference/library/3b/#zer-fl",
5699+ "desc": "Used in the Hoon standard library."
5700+ }, {
5701+ "name": "Subtract bottom from top",
5702+ "symbol": "zig:mu",
5703+ "usage": "stdlib",
5704+ "link": "https://urbit.org/docs/reference/library/4j/#zig-mu",
5705+ "desc": "Used in the Hoon standard library."
5706+ }, {
5707+ "name": "Turn lists into single list by promoting elements from sublists",
5708+ "symbol": "zing",
5709+ "usage": "stdlib",
5710+ "link": "https://urbit.org/docs/reference/library/2b/#zing",
5711+ "desc": "Used in the Hoon standard library."
5712+ }, {
5713+ "name": "Concatenate into atom",
5714+ "symbol": "zug:mu",
5715+ "usage": "stdlib",
5716+ "link": "https://urbit.org/docs/reference/library/4j/#zug-mu",
5717+ "desc": "Used in the Hoon standard library."
5718+ }, {
5719+ "name": "Parse prefixed dimes from IP, loobean, or floating point",
5720+ "symbol": "zust:so",
5721+ "usage": "stdlib",
5722+ "link": "https://urbit.org/docs/reference/library/4l/#zust-so",
5723+ "desc": "Used in the Hoon standard library."
5724+ }, {
5725+ "name": "Lookup byte in 256 sub box",
5726+ "symbol": "zyft:un",
5727+ "usage": "stdlib",
5728+ "link": "https://urbit.org/docs/reference/library/3f/#zyft-un",
5729+ "desc": "Used in the Hoon standard library."
5730+ }, {
5731+ "name": "Reverse lookup byte in 256 sub box",
5732+ "symbol": "zyrt:un",
5733+ "usage": "stdlib",
5734+ "link": "https://urbit.org/docs/reference/library/3f/#zyrt-un",
5735+ "desc": "Used in the Hoon standard library."
5736+ }
5737+]
static/runes.jsdeleted−982
@@ -1,982 +0,0 @@
1−var runes = [
2− {
3− "name": "dot",
4− "symbol": ".",
5− "usage": "Nock",
6− "link": "/docs/reference/hoon-expressions/rune/dot/",
7− "desc": "Runes used for carrying out Nock operations in Hoon."
8− },
9− {
10− "name": "dotket",
11− "symbol": ".^",
12− "usage": "Nock",
13− "link": "/docs/reference/hoon-expressions/rune/dot/#dotket",
14− "desc": "<code>[%dtkt p=spec q=hoon]</code>: load from the Arvo namespace with a fake Nock instruction: 'Nock <code>12</code>''."
15− },
16− {
17− "name": "dotlus",
18− "symbol": ".+",
19− "usage": "Nock",
20− "link": "/docs/reference/hoon-expressions/rune/dot/#dotlus",
21− "desc": "<code>[%dtls p=hoon]</code>: increment an atom with Nock <code>4</code>."
22− },
23− {
24− "name": "dottar",
25− "symbol": ".*",
26− "usage": "Nock",
27− "link": "/docs/reference/hoon-expressions/rune/dot/#dottar",
28− "desc": "<code>[%dttr p=hoon q=hoon]</code>: evaluate with Nock <code>2</code>."
29− },
30− {
31− "name": "dottis",
32− "symbol": ".=",
33− "usage": "Nock",
34− "link": "/docs/reference/hoon-expressions/rune/dot/#dottis",
35− "desc": "<code>[%dtts p=hoon q=hoon]</code>: test for equality with Nock <code>5</code>."
36− },
37− {
38− "name": "dotwut",
39− "symbol": ".?",
40− "usage": "Nock",
41− "link": "/docs/reference/hoon-expressions/rune/dot/#dotwut",
42− "desc": "<code>[%dtwt p=hoon]</code>: test for cell or atom with Nock <code>3</code>."
43− },
44− {
45− "name": "zap",
46− "symbol": "!",
47− "usage": "wild",
48− "link": "/docs/reference/hoon-expressions/rune/zap/",
49− "desc": "Wildcard category. Expressions that don't fit anywhere else go here."
50− },
51− {
52− "name": "zapgar",
53− "symbol": "!>",
54− "usage": "wild",
55− "link": "/docs/reference/hoon-expressions/rune/zap/#zapgar",
56− "desc": "<code>[%zpgr p=hoon]</code>: wrap a noun in its type."
57− },
58− {
59− "name": "zapcol",
60− "symbol": "!:",
61− "usage": "wild",
62− "link": "/docs/reference/hoon-expressions/rune/zap/#zapcol",
63− "desc": "<code>[%dbug p=hoon]</code>: turn on stack trace"
64− },
65− {
66− "name": "zapdot",
67− "symbol": "!.",
68− "usage": "wild",
69− "link": "/docs/reference/hoon-expressions/rune/zap/#zapdot",
70− "desc": "Turn off stack trace for a subexpression <code>p</code>"
71− },
72− {
73− "name": "zaptis",
74− "symbol": "!=",
75− "usage": "wild",
76− "link": "/docs/reference/hoon-expressions/rune/zap/#zaptis",
77− "desc": "<code>[%zpts p=hoon]</code>: make the Nock formula for a Hoon expression."
78− },
79− {
80− "name": "zapwut",
81− "symbol": "!?",
82− "usage": "wild",
83− "link": "/docs/reference/hoon-expressions/rune/zap/#zapwut",
84− "desc": "<code>[%zpwt p=@ q=hoon]</code>: restrict Hoon version."
85− },
86− {
87− "name": "zapzap",
88− "symbol": "!!",
89− "usage": "wild",
90− "link": "/docs/reference/hoon-expressions/rune/zap/#zapzap",
91− "desc": "<code>[%zpzp ~]</code>: crash."
92− },
93− {
94− "name": "tis",
95− "symbol": "=",
96− "usage": "Subject Modification",
97− "link": "/docs/reference/hoon-expressions/rune/tis/",
98− "desc": "Runes used to modify the subject."
99− },
100− {
101− "name": "tisgar",
102− "symbol": "=>",
103− "usage": "Subject Modification",
104− "link": "/docs/reference/hoon-expressions/rune/tis/#tisgar",
105− "desc": "<code>[%tsgr p=hoon q=hoon]</code>: compose two expressions."
106− },
107− {
108− "name": "tisbar",
109− "symbol": "=|",
110− "usage": "Subject Modification",
111− "link": "/docs/reference/hoon-expressions/rune/tis/#tisbar",
112− "desc": "<code>[%tsbr p=spec q=hoon]</code>: combine a default type value with the subject."
113− },
114− {
115− "name": "tiscol",
116− "symbol": "=:",
117− "usage": "Subject Modification",
118− "link": "/docs/reference/hoon-expressions/rune/tis/#tiscol",
119− "desc": "<code>[%tscl p=(list (pair wing hoon)) q=hoon]</code>: change multiple legs in the subject."
120− },
121− {
122− "name": "tiscom",
123− "symbol": "=,",
124− "usage": "Subject Modification",
125− "link": "/docs/reference/hoon-expressions/rune/tis/#tiscom",
126− "desc": "<code>[%tscm p=hoon q=hoon]</code>: expose namespace"
127− },
128− {
129− "name": "tisdot",
130− "symbol": "=.",
131− "usage": "Subject Modification",
132− "link": "/docs/reference/hoon-expressions/rune/tis/#tisdot",
133− "desc": "<code>[%tsdt p=wing q=hoon r=hoon]</code>: change one leg in the subject."
134− },
135− {
136− "name": "tishep",
137− "symbol": "=-",
138− "usage": "Subject Modification",
139− "link": "/docs/reference/hoon-expressions/rune/tis/#tishep",
140− "desc": "<code>[%tshp p=hoon q=hoon]</code>: combine a new noun with the subject, inverted."
141− },
142− {
143− "name": "tisket",
144− "symbol": "=^",
145− "usage": "Subject Modification",
146− "link": "/docs/reference/hoon-expressions/rune/tis/#tisket",
147− "desc": "<code>[%tskt p=skin q=wing r=hoon s=hoon]</code>: pin the head of a pair; change"
148− },
149− {
150− "name": "tisgal",
151− "symbol": "=<",
152− "usage": "Subject Modification",
153− "link": "/docs/reference/hoon-expressions/rune/tis/#tisgal",
154− "desc": "<code>[%tsgl p=hoon q=hoon]</code>: compose two expressions, inverted."
155− },
156− {
157− "name": "tislus",
158− "symbol": "=+",
159− "usage": "Subject Modification",
160− "link": "/docs/reference/hoon-expressions/rune/tis/#tislus",
161− "desc": "<code>[%tsls p=hoon q=hoon]</code>: combine a new noun with the subject."
162− },
163− {
164− "name": "tismic",
165− "symbol": "=;",
166− "usage": "Subject Modification",
167− "link": "/docs/reference/hoon-expressions/rune/tis/#tismic",
168− "desc": "<code>[%tssm p=skin q=hoon r=hoon]</code>: combine a named noun with the subject, possibly with type annotation; inverted order."
169− },
170− {
171− "name": "tisfas",
172− "symbol": "=/",
173− "usage": "Subject Modification",
174− "link": "/docs/reference/hoon-expressions/rune/tis/#tisfas",
175− "desc": "<code>[%tsfs p=skin q=hoon r=hoon]</code>: combine a named noun with the subject, possibly with type annotation."
176− },
177− {
178− "name": "tissig",
179− "symbol": "=~",
180− "usage": "Subject Modification",
181− "link": "/docs/reference/hoon-expressions/rune/tis/#tissig",
182− "desc": "<code>[%tssg p=(list hoon)]</code>: compose many expressions."
183− },
184− {
185− "name": "tistar",
186− "symbol": "=*",
187− "usage": "Subject Modification",
188− "link": "/docs/reference/hoon-expressions/rune/tis/#tistar",
189− "desc": "<code>[%tstr p=term q=hoon r=hoon]</code>: define an alias."
190− },
191− {
192− "name": "tiswut",
193− "symbol": "=?",
194− "usage": "Subject Modification",
195− "link": "/docs/reference/hoon-expressions/rune/tis/#tiswut",
196− "desc": "<code>[$tswt p=wing q=hoon r=hoon s=hoon]</code>: conditionally change one leg in the subject."
197− },
198− {
199− "name": "wut",
200− "symbol": "?",
201− "usage": "Conditionals",
202− "link": "/docs/reference/hoon-expressions/rune/wut/",
203− "desc": "Runes used for branching on conditionals."
204− },
205− {
206− "name": "wutgar",
207− "symbol": "?>",
208− "usage": "Conditionals",
209− "link": "/docs/reference/hoon-expressions/rune/wut/#wutgar",
210− "desc": "<code>[%wtbn p=hoon q=hoon]</code>: positive assertion."
211− },
212− {
213− "name": "wutbar",
214− "symbol": "?|",
215− "usage": "Conditionals",
216− "link": "/docs/reference/hoon-expressions/rune/wut/#wutbar",
217− "desc": "<code>[%wtbr p=(list hoon)]</code>: logical OR."
218− },
219− {
220− "name": "wutcol",
221− "symbol": "?:",
222− "usage": "Conditionals",
223− "link": "/docs/reference/hoon-expressions/rune/wut/#wutcol",
224− "desc": "<code>[%wtcl p=hoon q=hoon r=hoon]</code>: branch on a boolean test."
225− },
226− {
227− "name": "wutdot",
228− "symbol": "?.",
229− "usage": "Conditionals",
230− "link": "/docs/reference/hoon-expressions/rune/wut/#wutdot",
231− "desc": "<code>[%wtdt p=hoon q=hoon r=hoon]</code>: branch on a boolean test, inverted."
232− },
233− {
234− "name": "wuthep",
235− "symbol": "?-",
236− "usage": "Conditionals",
237− "link": "/docs/reference/hoon-expressions/rune/wut/#wuthep",
238− "desc": "<code>[%wthp p=wing q=(list (pair spec value))]</code>: switch against a union, with no default."
239− },
240− {
241− "name": "wutket",
242− "symbol": "?^",
243− "usage": "Conditionals",
244− "link": "/docs/reference/hoon-expressions/rune/wut/#wutket",
245− "desc": "<code>[%wtkt p=wing q=hoon r=hoon]</code>: branch on whether a wing"
246− },
247− {
248− "name": "wutgal",
249− "symbol": "?<",
250− "usage": "Conditionals",
251− "link": "/docs/reference/hoon-expressions/rune/wut/#wutgal",
252− "desc": "<code>[%wtgl p=hoon q=hoon]</code>: negative assertion."
253− },
254− {
255− "name": "wutlus",
256− "symbol": "?+",
257− "usage": "Conditionals",
258− "link": "/docs/reference/hoon-expressions/rune/wut/#wutlus",
259− "desc": "<code>[%wtls p=wing q=hoon r=(list (pair spec hoon))]</code>: switch against"
260− },
261− {
262− "name": "wutpam",
263− "symbol": "?&",
264− "usage": "Conditionals",
265− "link": "/docs/reference/hoon-expressions/rune/wut/#wutpam",
266− "desc": "<code>[%wtpd p=(list hoon)]</code>: logical AND."
267− },
268− {
269− "name": "wutsig",
270− "symbol": "?~",
271− "usage": "Conditionals",
272− "link": "/docs/reference/hoon-expressions/rune/wut/#wutsig",
273− "desc": "<code>[%wtsg p=wing q=hoon r=hoon]</code>: branch on whether a wing of the subject is null."
274− },
275− {
276− "name": "wuttis",
277− "symbol": "?=",
278− "usage": "Conditionals",
279− "link": "/docs/reference/hoon-expressions/rune/wut/#wuttis",
280− "desc": "<code>[%wtts p=spec q=wing]</code>: test pattern match."
281− },
282− {
283− "name": "wutpat",
284− "symbol": "?@",
285− "usage": "Conditionals",
286− "link": "/docs/reference/hoon-expressions/rune/wut/#wutpat",
287− "desc": "<code>[%wtpt p=wing q=hoon r=hoon]</code>: branch on whether a wing of the subject is an atom."
288− },
289− {
290− "name": "wutzap",
291− "symbol": "?!",
292− "usage": "Conditionals",
293− "link": "/docs/reference/hoon-expressions/rune/wut/#wutzap",
294− "desc": "<code>[%wtzp p=hoon]</code>: logical NOT."
295− },
296− {
297− "name": "bar",
298− "symbol": "|",
299− "usage": "Cores",
300− "link": "/docs/reference/hoon-expressions/rune/bar/",
301− "desc": "Runes used to produce cores."
302− },
303− {
304− "name": "barcab",
305− "symbol": "|_",
306− "usage": "Cores",
307− "link": "/docs/reference/hoon-expressions/rune/bar/#barcab",
308− "desc": "Produce a **door** (a core with a sample)."
309− },
310− {
311− "name": "barcen",
312− "symbol": "|%",
313− "usage": "Cores",
314− "link": "/docs/reference/hoon-expressions/rune/bar/#barcen",
315− "desc": "Produce a core, <code>[battery payload]</code>."
316− },
317− {
318− "name": "barcol",
319− "symbol": "|:",
320− "usage": "Cores",
321− "link": "/docs/reference/hoon-expressions/rune/bar/#barcol",
322− "desc": "Produce a gate with a custom sample."
323− },
324− {
325− "name": "bardot",
326− "symbol": "|.",
327− "usage": "Cores",
328− "link": "/docs/reference/hoon-expressions/rune/bar/#bardot",
329− "desc": "Produce a trap (a core with one arm <code>$</code>)."
330− },
331− {
332− "name": "barhep",
333− "symbol": "|-",
334− "usage": "Cores",
335− "link": "/docs/reference/hoon-expressions/rune/bar/#barhep",
336− "desc": "Produce a trap (a core with one arm <code>$</code>) and evaluate it."
337− },
338− {
339− "name": "barket",
340− "symbol": "|^",
341− "usage": "Cores",
342− "link": "/docs/reference/hoon-expressions/rune/bar/#barket",
343− "desc": "Produce a core whose battery includes a <code>$</code> arm and compute the latter."
344− },
345− {
346− "name": "barsig",
347− "symbol": "|~",
348− "usage": "Cores",
349− "link": "/docs/reference/hoon-expressions/rune/bar/#barsig",
350− "desc": "Produce an iron gate."
351− },
352− {
353− "name": "bartar",
354− "symbol": "|*",
355− "usage": "Cores",
356− "link": "/docs/reference/hoon-expressions/rune/bar/#bartar",
357− "desc": "Produce a wet gate (one-armed core with sample)."
358− },
359− {
360− "name": "bartis",
361− "symbol": "|=",
362− "usage": "Cores",
363− "link": "/docs/reference/hoon-expressions/rune/bar/#bartis",
364− "desc": "Produce a gate (a one-armed core with a sample)."
365− },
366− {
367− "name": "barpat",
368− "symbol": "|@",
369− "usage": "Cores",
370− "link": "/docs/reference/hoon-expressions/rune/bar/#barpat",
371− "desc": "Produce a 'wet' core <code>[battery payload]</code>."
372− },
373− {
374− "name": "barwut",
375− "symbol": "|?",
376− "usage": "Cores",
377− "link": "/docs/reference/hoon-expressions/rune/bar/#barwut",
378− "desc": "Produce a lead trap."
379− },
380− {
381− "name": "lus",
382− "symbol": "+",
383− "usage": "Arms",
384− "link": "/docs/reference/hoon-expressions/rune/lus/",
385− "desc": "Runes used to define arms in a core."
386− },
387− {
388− "name": "lusbar",
389− "symbol": "+|",
390− "usage": "Arms",
391− "link": "/docs/reference/hoon-expressions/rune/lus/#lusbar",
392− "desc": "Chapter label."
393− },
394− {
395− "name": "lusbuc",
396− "symbol": "+$",
397− "usage": "Arms",
398− "link": "/docs/reference/hoon-expressions/rune/lus/#lusbuc",
399− "desc": "Produce a structure arm (type definition)."
400− },
401− {
402− "name": "luslus",
403− "symbol": "++",
404− "usage": "Arms",
405− "link": "/docs/reference/hoon-expressions/rune/lus/#luslus",
406− "desc": "Produce a normal arm."
407− },
408− {
409− "name": "lustar",
410− "symbol": "+*",
411− "usage": "Arms",
412− "link": "/docs/reference/hoon-expressions/rune/lus/#lustar",
413− "desc": "Produce a type constructor arm."
414− },
415− {
416− "name": "col",
417− "symbol": ":",
418− "usage": "Cells",
419− "link": "/docs/reference/hoon-expressions/rune/col/",
420− "desc": "Runes used to produce cells, which are pairs of nouns."
421− },
422− {
423− "name": "colcab",
424− "symbol": ":_",
425− "usage": "Cells",
426− "link": "/docs/reference/hoon-expressions/rune/col/#colcab",
427− "desc": "<code>[%clcb p=hoon q=hoon]</code>; construct a cell, inverted."
428− },
429− {
430− "name": "colcol",
431− "symbol": "::",
432− "usage": "Cells",
433− "link": "/docs/reference/hoon-expressions/rune/col/#colcol",
434− "desc": "Code comment."
435− },
436− {
437− "name": "colhep",
438− "symbol": ":-",
439− "usage": "Cells",
440− "link": "/docs/reference/hoon-expressions/rune/col/#colhep",
441− "desc": "<code>[%clhp p=hoon q=hoon]</code>: construct a cell (2-tuple)."
442− },
443− {
444− "name": "colket",
445− "symbol": ":^",
446− "usage": "Cells",
447− "link": "/docs/reference/hoon-expressions/rune/col/#colket",
448− "desc": "<code>[%clkt p=hoon q=hoon r=hoon s=hoon]</code>: construct a quadruple (4-tuple)."
449− },
450− {
451− "name": "collus",
452− "symbol": ":+",
453− "usage": "Cells",
454− "link": "/docs/reference/hoon-expressions/rune/col/#collus",
455− "desc": "<code>[%clls p=hoon q=hoon r=hoon]</code>: construct a triple (3-tuple)."
456− },
457− {
458− "name": "colsig",
459− "symbol": ":~",
460− "usage": "Cells",
461− "link": "/docs/reference/hoon-expressions/rune/col/#colsig",
462− "desc": "<code>[%clsg p=(list hoon)]</code>: construct a null-terminated list."
463− },
464− {
465− "name": "coltar",
466− "symbol": ":*",
467− "usage": "Cells",
468− "link": "/docs/reference/hoon-expressions/rune/col/#coltar",
469− "desc": "<code>[%cltr p=(list hoon)]</code>: construct an n-tuple."
470− },
471− {
472− "name": "cen",
473− "symbol": "%",
474− "usage": "Calls",
475− "link": "/docs/reference/hoon-expressions/rune/cen/",
476− "desc": "Runes used for making function calls in Hoon."
477− },
478− {
479− "name": "cencab",
480− "symbol": "%_",
481− "usage": "Calls",
482− "link": "/docs/reference/hoon-expressions/rune/cen/#cencab",
483− "desc": "Resolve a wing with changes, preserving type."
484− },
485− {
486− "name": "cencol",
487− "symbol": "%:",
488− "usage": "Calls",
489− "link": "/docs/reference/hoon-expressions/rune/cen/#cencol",
490− "desc": "Call a gate with many arguments."
491− },
492− {
493− "name": "cendot",
494− "symbol": "%.",
495− "usage": "Calls",
496− "link": "/docs/reference/hoon-expressions/rune/cen/#cendot",
497− "desc": "Call a gate (function), inverted."
498− },
499− {
500− "name": "cenhep",
501− "symbol": "%-",
502− "usage": "Calls",
503− "link": "/docs/reference/hoon-expressions/rune/cen/#cenhep",
504− "desc": "Call a gate (function)."
505− },
506− {
507− "name": "cenket",
508− "symbol": "%^",
509− "usage": "Calls",
510− "link": "/docs/reference/hoon-expressions/rune/cen/#cenket",
511− "desc": "Call gate with triple sample."
512− },
513− {
514− "name": "cenlus",
515− "symbol": "%+",
516− "usage": "Calls",
517− "link": "/docs/reference/hoon-expressions/rune/cen/#cenlus",
518− "desc": "Call gate with a cell sample."
519− },
520− {
521− "name": "censig",
522− "symbol": "%~",
523− "usage": "Calls",
524− "link": "/docs/reference/hoon-expressions/rune/cen/#censig",
525− "desc": "Evaluate an arm in a door."
526− },
527− {
528− "name": "centar",
529− "symbol": "%*",
530− "usage": "Calls",
531− "link": "/docs/reference/hoon-expressions/rune/cen/#centar",
532− "desc": "Evaluate an expression, then resolve a wing with changes."
533− },
534− {
535− "name": "centis",
536− "symbol": "%=",
537− "usage": "Calls",
538− "link": "/docs/reference/hoon-expressions/rune/cen/#centis",
539− "desc": "Resolve a wing with changes."
540− },
541− {
542− "name": "ket",
543− "symbol": "^",
544− "usage": "Casts",
545− "link": "/docs/reference/hoon-expressions/rune/ket/",
546− "desc": "Runes that let us adjust types without violating type constraints."
547− },
548− {
549− "name": "ketbar",
550− "symbol": "^|",
551− "usage": "Casts",
552− "link": "/docs/reference/hoon-expressions/rune/ket/#ketbar",
553− "desc": "<code>[%ktbr p=hoon]</code>: convert a gold core to an iron core (contravariant)."
554− },
555− {
556− "name": "ketcol",
557− "symbol": "^:",
558− "usage": "Casts",
559− "link": "/docs/reference/hoon-expressions/rune/ket/#ketcol",
560− "desc": "<code>[%ktcl p=spec]</code>: 'factory' gate for type <code>p</code>."
561− },
562− {
563− "name": "ketdot",
564− "symbol": "^.",
565− "usage": "Casts",
566− "link": "/docs/reference/hoon-expressions/rune/ket/#ketdot",
567− "desc": "<code>[%ktdt p=hoon q=hoon]</code>: typecast on value produced by passing <code>q</code> to <code>p</code>."
568− },
569− {
570− "name": "kethep",
571− "symbol": "^-",
572− "usage": "Casts",
573− "link": "/docs/reference/hoon-expressions/rune/ket/#kethep",
574− "desc": "<code>[%kthp p=spec q=hoon]</code>: typecast by explicit type label."
575− },
576− {
577− "name": "ketlus",
578− "symbol": "^+",
579− "usage": "Casts",
580− "link": "/docs/reference/hoon-expressions/rune/ket/#ketlus",
581− "desc": "<code>[%ktls p=hoon q=hoon]</code>: typecast by inferred type."
582− },
583− {
584− "name": "ketpam",
585− "symbol": "^&",
586− "usage": "Casts",
587− "link": "/docs/reference/hoon-expressions/rune/ket/#ketpam",
588− "desc": "<code>[%ktpd p=hoon]</code>: convert a core to a zinc core (covariant)."
589− },
590− {
591− "name": "ketsig",
592− "symbol": "^~",
593− "usage": "Casts",
594− "link": "/docs/reference/hoon-expressions/rune/ket/#ketsig",
595− "desc": "<code>[%ktsg p=hoon]</code>: fold constant at compile time."
596− },
597− {
598− "name": "kettar",
599− "symbol": "^*",
600− "usage": "Casts",
601− "link": "/docs/reference/hoon-expressions/rune/ket/#kettar",
602− "desc": "<code>[%kttr p=spec]</code>: Produce example type value."
603− },
604− {
605− "name": "kettis",
606− "symbol": "^=",
607− "usage": "Casts",
608− "link": "/docs/reference/hoon-expressions/rune/ket/#kettis",
609− "desc": "<code>[%ktts p=skin q=hoon]</code>: Bind name to a value."
610− },
611− {
612− "name": "ketwut",
613− "symbol": "^?",
614− "usage": "Casts",
615− "link": "/docs/reference/hoon-expressions/rune/ket/#ketwut",
616− "desc": "<code>[%ktwt p=hoon]</code>: convert any core to a lead core (bivariant)."
617− },
618− {
619− "name": "buc",
620− "symbol": "$",
621− "usage": "Structures",
622− "link": "/docs/reference/hoon-expressions/rune/buc/",
623− "desc": "Runes used for defining custom types."
624− },
625− {
626− "name": "buccab",
627− "symbol": "$_",
628− "usage": "Structures",
629− "link": "/docs/reference/hoon-expressions/rune/buc/#buccab",
630− "desc": "<code>[%bscb p=hoon]</code>: structure that normalizes to an example."
631− },
632− {
633− "name": "buccen",
634− "symbol": "$%",
635− "usage": "Structures",
636− "link": "/docs/reference/hoon-expressions/rune/buc/#buccen",
637− "desc": "<code>[%bscn p=(list spec)]</code>: structure which recognizes a union tagged by head atom."
638− },
639− {
640− "name": "buccol",
641− "symbol": "$:",
642− "usage": "Structures",
643− "link": "/docs/reference/hoon-expressions/rune/buc/#buccol",
644− "desc": "<code>[%bscl p=(list spec)]</code>: form a cell type."
645− },
646− {
647− "name": "buchep",
648− "symbol": "$-",
649− "usage": "Structures",
650− "link": "/docs/reference/hoon-expressions/rune/buc/#buchep",
651− "desc": "<code>[%bshp p=spec q=spec]</code>: structure that normalizes to an example gate."
652− },
653− {
654− "name": "bucket",
655− "symbol": "$^",
656− "usage": "Structures",
657− "link": "/docs/reference/hoon-expressions/rune/buc/#bucket",
658− "desc": "<code>[%bskt p=spec q=spec]</code>: structure which normalizes a union tagged by head depth (cell)."
659− },
660− {
661− "name": "bucsig",
662− "symbol": "$~",
663− "usage": "Structures",
664− "link": "/docs/reference/hoon-expressions/rune/buc/#bucsig",
665− "desc": "<code>[%bssg p=hoon q=spec]</code>: define a custom type default value"
666− },
667− {
668− "name": "bucpat",
669− "symbol": "$@",
670− "usage": "Structures",
671− "link": "/docs/reference/hoon-expressions/rune/buc/#bucpat",
672− "desc": "<code>[%bsvt p=spec q=spec]</code>: structure which normalizes a union tagged by head depth (atom)."
673− },
674− {
675− "name": "buctis",
676− "symbol": "$=",
677− "usage": "Structures",
678− "link": "/docs/reference/hoon-expressions/rune/buc/#buctis",
679− "desc": "<code>[%bsts p=skin q=spec]</code>: structure which wraps a face around another structure."
680− },
681− {
682− "name": "bucwut",
683− "symbol": "$?",
684− "usage": "Structures",
685− "link": "/docs/reference/hoon-expressions/rune/buc/#bucwut",
686− "desc": "<code>[%bswt p=(list spec)]</code>: form a type from a union of other types."
687− },
688− {
689− "name": "mic",
690− "symbol": ";",
691− "usage": "Make",
692− "link": "/docs/reference/hoon-expressions/rune/mic/",
693− "desc": "Miscellaneous useful macros."
694− },
695− {
696− "name": "miccol",
697− "symbol": ";:",
698− "usage": "Make",
699− "link": "/docs/reference/hoon-expressions/rune/mic/#miccol",
700− "desc": "<code>[%mccl p=hoon q=(list hoon)]</code>: call a binary function as an n-ary function."
701− },
702− {
703− "name": "miclus",
704− "symbol": ";+",
705− "usage": "Make",
706− "link": "/docs/reference/hoon-expressions/rune/mic/#miclus",
707− "desc": "make a single XML node (Sail)"
708− },
709− {
710− "name": "micmic",
711− "symbol": ";;",
712− "usage": "Make",
713− "link": "/docs/reference/hoon-expressions/rune/mic/#micmic",
714− "desc": "<code>[%mcmc p=spec q=hoon]</code>: normalize with a mold, asserting fixpoint."
715− },
716− {
717− "name": "micfas",
718− "symbol": ";/",
719− "usage": "Make",
720− "link": "/docs/reference/hoon-expressions/rune/mic/#micfas",
721− "desc": "<code>[%mcnt p=hoon]</code>: tape as XML element."
722− },
723− {
724− "name": "micsig",
725− "symbol": ";~",
726− "usage": "Make",
727− "link": "/docs/reference/hoon-expressions/rune/mic/#micsig",
728− "desc": "<code>[%mcsg p=hoon q=(list hoon)]</code>: glue a pipeline together with a"
729− },
730− {
731− "name": "mictar",
732− "symbol": ";*",
733− "usage": "Make",
734− "link": "/docs/reference/hoon-expressions/rune/mic/#mictar",
735− "desc": "Make a list of XML nodes from complex Hoon expression (Sail)."
736− },
737− {
738− "name": "mictis",
739− "symbol": ";=",
740− "usage": "Make",
741− "link": "/docs/reference/hoon-expressions/rune/mic/#mictis",
742− "desc": "Make a list of XML nodes (Sail)."
743− },
744− {
745− "name": "sig",
746− "symbol": "~",
747− "usage": "Hints",
748− "link": "/docs/reference/hoon-expressions/rune/sig/",
749− "desc": "Runes that use Nock <code>11</code> to pass non-semantic info to the interpreter."
750− },
751− {
752− "name": "siggar",
753− "symbol": "~>",
754− "usage": "Hints",
755− "link": "/docs/reference/hoon-expressions/rune/sig/#siggar",
756− "desc": "<code>[%sgbn p=$@(term [p=term q=hoon]) q=hoon]</code>: raw hint, applied"
757− },
758− {
759− "name": "sigbar",
760− "symbol": "~|",
761− "usage": "Hints",
762− "link": "/docs/reference/hoon-expressions/rune/sig/#sigbar",
763− "desc": "<code>[%sgbr p=hoon q=hoon]</code>: tracing printf."
764− },
765− {
766− "name": "sigbuc",
767− "symbol": "~$",
768− "usage": "Hints",
769− "link": "/docs/reference/hoon-expressions/rune/sig/#sigbuc",
770− "desc": "<code>[%sgbs p=term q=hoon]</code>: profiling hit counter."
771− },
772− {
773− "name": "sigcab",
774− "symbol": "~_",
775− "usage": "Hints",
776− "link": "/docs/reference/hoon-expressions/rune/sig/#sigcab",
777− "desc": "<code>[%sgcb p=hoon q=hoon]</code>: user-formatted tracing printf."
778− },
779− {
780− "name": "sigcen",
781− "symbol": "~%",
782− "usage": "Hints",
783− "link": "/docs/reference/hoon-expressions/rune/sig/#sigcen",
784− "desc": "<code>[%sgcn p=term q=wing r=(list [term hoon]) s=hoon]</code>: jet registration."
785− },
786− {
787− "name": "siggal",
788− "symbol": "~<",
789− "usage": "Hints",
790− "link": "/docs/reference/hoon-expressions/rune/sig/#siggal",
791− "desc": "<code>[%sgld p=$@(term [p=term q=hoon]) q=hoon]</code>: raw hint, applied to product."
792− },
793− {
794− "name": "siglus",
795− "symbol": "~+",
796− "usage": "Hints",
797− "link": "/docs/reference/hoon-expressions/rune/sig/#siglus",
798− "desc": "<code>[%sgls p=hoon]</code>: cache a computation."
799− },
800− {
801− "name": "sigfas",
802− "symbol": "~/",
803− "usage": "Hints",
804− "link": "/docs/reference/hoon-expressions/rune/sig/#sigfas",
805− "desc": "<code>[%sgnt p=term q=hoon]</code>: jet registration for gate with"
806− },
807− {
808− "name": "sigpam",
809− "symbol": "~&",
810− "usage": "Hints",
811− "link": "/docs/reference/hoon-expressions/rune/sig/#sigpam",
812− "desc": "<code>[%sgpd p=hoon q=hoon]</code>: debugging printf."
813− },
814− {
815− "name": "sigtis",
816− "symbol": "~=",
817− "usage": "Hints",
818− "link": "/docs/reference/hoon-expressions/rune/sig/#sigtis",
819− "desc": "<code>[%sgts p=hoon q=hoon]</code>: detect duplicate."
820− },
821− {
822− "name": "sigwut",
823− "symbol": "~?",
824− "usage": "Hints",
825− "link": "/docs/reference/hoon-expressions/rune/sig/#sigwut",
826− "desc": "<code>[%sgwt p=hoon q=hoon r=hoon]</code>: conditional debug printf."
827− },
828− {
829− "name": "sigzap",
830− "symbol": "~!",
831− "usage": "Hints",
832− "link": "/docs/reference/hoon-expressions/rune/sig/#sigzap",
833− "desc": "<code>[%sgzp p=hoon q=hoon]</code>: print type on compilation fail."
834− },
835− {
836− "name": "terminators",
837− "symbol": "--,",
838− "usage": "Terminators",
839− "link": "/docs/reference/hoon-expressions/rune/terminators/",
840− "desc": "Runes used to terminate expressions."
841− },
842− {
843− "name": "hephep",
844− "symbol": "--",
845− "usage": "Terminators",
846− "link": "/docs/reference/hoon-expressions/rune/terminators/#hephep",
847− "desc": "The <code>--</code> rune is used to indicate the end of a core expression."
848− },
849− {
850− "name": "tistis",
851− "symbol": "==",
852− "usage": "Terminators",
853− "link": "/docs/reference/hoon-expressions/rune/terminators/#tistis",
854− "desc": "The <code>==</code> rune is used to indicate the end of a 'jogging' or 'running' series of Hoon expressions."
855− },
856− {
857− "name": "fas",
858− "symbol": "/",
859− "usage": "Ford",
860− "link": "/docs/tutorials/arvo/ford/#ford-runes",
861− "desc": "Runes specific to Ford, not considered to be Hoon runes."
862− },
863− {
864− "name": "faslus",
865− "symbol": "/+",
866− "usage": "Ford",
867− "link": "/docs/tutorials/arvo/ford/#faslus",
868− "desc": "Ford rune. Import from <code>lib/</code>"
869− },
870− {
871− "name": "fashep",
872− "symbol": "/-",
873− "usage": "Ford",
874− "link": "/docs/tutorials/arvo/ford/#fashep",
875− "desc": "Ford rune. Import from <code>sur/</code>"
876− },
877− {
878− "name": "fassig",
879− "symbol": "/~",
880− "usage": "Ford",
881− "link": "/docs/tutorials/arvo/ford/#fassig",
882− "desc": "Ford rune. Twig by hand."
883− },
884− {
885− "name": "fasfas",
886− "symbol": "//",
887− "usage": "Ford",
888− "link": "/docs/tutorials/arvo/ford/#fasfas",
889− "desc": "Ford rune. Include a file by relative path."
890− },
891− {
892− "name": "fastis",
893− "symbol": "/=",
894− "usage": "Ford",
895− "link": "/docs/tutorials/arvo/ford/#fastis",
896− "desc": "Ford rune. Wrap a face around an included horn."
897− },
898− {
899− "name": "fascol",
900− "symbol": "/:",
901− "usage": "Ford",
902− "link": "/docs/tutorials/arvo/ford/#fascol",
903− "desc": "Ford rune. Evaluate at path, and <code>/mark/</code> at current path"
904− },
905− {
906− "name": "faszap",
907− "symbol": "/!",
908− "usage": "Ford",
909− "link": "/docs/tutorials/arvo/ford/#faszap",
910− "desc": "Ford rune. <code>/!mark/</code> evaluates as Hoon, then passes through mark."
911− },
912− {
913− "name": "faspam",
914− "symbol": "/&",
915− "usage": "Ford",
916− "link": "/docs/tutorials/arvo/ford/#faspam",
917− "desc": "Ford rune. Pass through a series of marks."
918− },
919− {
920− "name": "fasbar",
921− "symbol": "/|",
922− "usage": "Ford",
923− "link": "/docs/tutorials/arvo/ford/#fasbar",
924− "desc": "Ford rune. Short-circuiting 'or' "
925− },
926− {
927− "name": "fascab",
928− "symbol": "/_",
929− "usage": "Ford",
930− "link": "/docs/tutorials/arvo/ford/#fascab",
931− "desc": "Ford rune. Runs horns on files in the current directory."
932− },
933− {
934− "name": "fasmic",
935− "symbol": "/;",
936− "usage": "Ford",
937− "link": "/docs/tutorials/arvo/ford/#fasmic",
938− "desc": "Ford rune. Operate on."
939− },
940− {
941− "name": "fascom",
942− "symbol": "/,",
943− "usage": "Ford",
944− "link": "/docs/tutorials/arvo/ford/#fascom",
945− "desc": "Ford rune. Switch by path."
946− },
947− {
948− "name": "fasdot",
949− "symbol": "/.",
950− "usage": "Ford",
951− "link": "/docs/tutorials/arvo/ford/#fasdot",
952− "desc": "Ford rune. Produces a list from a sequence of horns."
953− },
954− {
955− "name": "fasket",
956− "symbol": "/^",
957− "usage": "Ford",
958− "link": "/docs/tutorials/arvo/ford/#fasket",
959− "desc": "Ford rune. Casts the result of a horn to a mold."
960− },
961− {
962− "name": "fashax",
963− "symbol": "/#",
964− "usage": "Ford",
965− "link": "/docs/tutorials/arvo/ford/#fashax",
966− "desc": "Ford rune. Inserts a dependency hash."
967− },
968− {
969− "name": "fasbuc",
970− "symbol": "/$",
971− "usage": "Ford",
972− "link": "/docs/tutorials/arvo/ford/#fasbuc",
973− "desc": "Ford rune. Process extra arguments."
974− },
975− {
976− "name": "fascen",
977− "symbol": "/%",
978− "usage": "Ford",
979− "link": "/docs/tutorials/arvo/ford/#fascen",
980− "desc": "Ford rune. Propagate extra arguments into renderers."
981− }
982− ]
static/scripts.js+99−87
@@ -4,42 +4,45 @@ function initHotKeys() {
44 var searchInput = document.getElementById('search');
55
66 document.addEventListener('keydown', function (event) {
7− if (event.defaultPrevented) {
8− return;
9− }
7+ if (event.defaultPrevented) {
8+ return;
9+ }
1010
11− var key = event.key || event.keyCode;
11+ var key = event.key || event.keyCode;
1212
13− // ESC to close search window
14− if (key === 'Escape' || key === 'Esc' || key === 27) {
15− document.body.classList.remove('has-active-search-window');
16− }
13+ // ESC to close search window
14+ if (key === 'Escape' || key === 'Esc' || key === 27) {
15+ document.body.classList.remove('has-active-search-window');
16+ }
1717
18− // / to open toggle window
19− if (key === '/' || key === 'Period' || key === 58) {
20− if (bodyEl.classList.contains('has-active-search-window')) {
21− // if it's already open don't do anything!
22− } else {
23− event.preventDefault();
24− document.body.classList.add('has-active-search-window');
25− searchInput.focus();
26− }
18+ // Ctrl or Meta + / to open toggle window
19+ if (
20+ (event.getModifierState("Control") || event.getModifierState("Meta")) &&
21+ (key === '/' || key === 'Period' || key === 58)
22+ ) {
23+ if (bodyEl.classList.contains('has-active-search-window')) {
24+ // if it's already open don't do anything!
25+ } else {
26+ event.preventDefault();
27+ document.body.classList.add('has-active-search-window');
28+ searchInput.focus();
2729 }
30+ }
2831
29− //when search is active TAB puts search input into focus
30− if (bodyEl.classList.contains('has-active-search-window')) {
31− if (key === 'Tab' || key === 'Tab' || key === 9) {
32− searchInput.focus();
33− }
32+ //when search is active TAB puts search input into focus
33+ if (bodyEl.classList.contains('has-active-search-window')) {
34+ if (key === 'Tab' || key === 'Tab' || key === 9) {
35+ searchInput.focus();
3436 }
37+ }
3538
36− if (bodyEl.classList.contains('has-active-search-window')) {
37− if (key === 'Enter' || key === 'Return' || key === 13) {
38− event.preventDefault();
39− let firstresult = document.querySelectorAll("div#full-results a")[0];
40− firstresult.click();
41− }
39+ if (bodyEl.classList.contains('has-active-search-window')) {
40+ if (key === 'Enter' || key === 'Return' || key === 13) {
41+ event.preventDefault();
42+ let firstresult = document.querySelectorAll("div#full-results a")[0];
43+ firstresult.click();
4244 }
45+ }
4346 });
4447};
4548
@@ -173,7 +176,7 @@ function makeTeaser(body, terms) {
173176}
174177
175178function formatSearchResultTitle(item) {
176− var pathArray = item.ref.split( '/' );
179+ var pathArray = item.ref.split('/');
177180
178181 var firstPartTitle = pathArray[3];
179182 let firstTitleCapitals = firstPartTitle.charAt(0).toUpperCase() + firstPartTitle.slice(1);
@@ -182,7 +185,7 @@ function formatSearchResultTitle(item) {
182185
183186 var fullTitle = firstTitleCapitals + '<span class="gray1 dib pl2">' + ' / ' + lastPartTitle + '</span>';
184187
185− return fullTitle;
188+ return fullTitle;
186189}
187190
188191function formatSearchResultItem(item, terms) {
@@ -193,7 +196,7 @@ function formatSearchResultItem(item, terms) {
193196 li.classList.add("search-results__item");
194197 var hrefA = item.ref;
195198 createA.setAttribute('href', hrefA);
196− createA.setAttribute('class','no-underline db pl1 pv2');
199+ createA.setAttribute('class', 'no-underline db pl1 pv2');
197200 createA.innerHTML = `<span class="capitalize ph3">${teaserTitle}</span>`;
198201 createA.innerHTML += `<span class='dn arrow fr'>↩</span>`;
199202 createA.innerHTML += `<div class="truncate pr2 ph3">${makeTeaser(item.doc.body, terms)}</div>`;
@@ -219,8 +222,8 @@ function initSearch() {
219222 bool: "AND",
220223 expand: true, // turn on partial word search
221224 fields: {
222− title: {boost: 2},
223− body: {boost: 1},
225+ title: { boost: 2 },
226+ body: { boost: 1 },
224227 }
225228 };
226229 var currentTerm = "";
@@ -232,9 +235,10 @@ function initSearch() {
232235 var searchWindow = document.getElementById('search-window');
233236 var searchActive = bodyEl.classList.contains('has-active-search-window');
234237
238+
235239 if (toggleSearchWindow !== null) {
236− toggleSearchWindow.onclick = function() {
237− inputReset.style.display="none";
240+ toggleSearchWindow.onclick = function () {
241+ inputReset.style.display = "none";
238242
239243 //activate search
240244 bodyEl.classList.toggle('has-active-search-window');
@@ -245,16 +249,16 @@ function initSearch() {
245249 searchResultsHeader.value = "";
246250 searchResults.style.display = searchInput.value.trim() === "" ? "none" : "block";
247251 }
248− searchOverlay.addEventListener('click', function(e){
249− if (!searchWindow.contains(e.target)){
252+ searchOverlay.addEventListener('click', function (e) {
253+ if (!searchWindow.contains(e.target)) {
250254 bodyEl.classList.toggle('has-active-search-window');
251255 }
252256 })
253257 }
254258
255− searchInput.addEventListener("keyup", debounce(function() {
256− inputReset.style.display="block";
257− glossaryResults.style.display="none";
259+ searchInput.addEventListener("keyup", debounce(function () {
260+ inputReset.style.display = "block";
261+ glossaryResults.style.display = "none";
258262 searchResultsHeader.value = "";
259263 var term = searchInput.value.trim();
260264 /*
@@ -268,17 +272,25 @@ function initSearch() {
268272 searchResults.style.overflowY = term === "" ? "hidden" : "scroll";
269273 searchResultsItems.innerHTML = "";
270274 if (term === "") {
271− inputReset.style.display="none";
275+ inputReset.style.display = "none";
272276 return;
273277 }
274278
275− for (let rune of runes) {
276− if (rune.symbol === term) {
277− glossaryResults.style.display="block";
279+ for (let entry of glossary) {
280+ if (entry.name === term.toLowerCase()) {
281+ glossaryResults.style.display = "block";
282+ glossaryResultsItem.innerHTML = `
283+ <a href="${entry.link}"><h3 class="black">${entry.name}</h3>
284+ <p class="black">${entry.desc}</p>
285+ <span class="db tr black fw5 mb3" style="font-family: 'Inter UI', sans-serif;">Read more in Glossary -></span></a>
286+ `
287+ break;
288+ } else if (entry.symbol === term) {
289+ glossaryResults.style.display = "block";
278290 glossaryResultsItem.innerHTML = `
279− <a href="${rune.link}"><h3 class="black"><code class="red3 mr1">${rune.symbol}</code> ${rune.name}</h3>
280− <p class="black">${rune.desc}</p>
281− <span class="db tr black fw5" style="font-family: 'Inter UI', sans-serif;">Read more in Documentation -></span></a>
291+ <a href="${entry.link}"><h3 class="black"><code class="pa0 red3 mr1">${entry.symbol}</code>${entry.name}</h3>
292+ <p class="black">${entry.desc}</p>
293+ <span class="db tr black fw5 mb3" style="font-family: 'Inter UI', sans-serif;">Read more in Documentation -></span></a>
282294 `
283295 }
284296 }
@@ -303,10 +315,10 @@ function initSearch() {
303315 }, 150));
304316
305317 // reset input button
306− inputReset.onclick=function(){
318+ inputReset.onclick = function () {
307319 document.getElementById('search-form').reset();
308320 }
309− searchForm.addEventListener("reset", function(event){
321+ searchForm.addEventListener("reset", function (event) {
310322 var e = document.createEvent('KeyboardEvent');
311323 e.initEvent("keyup", false, true);
312324 searchInput.dispatchEvent(e);
@@ -315,9 +327,8 @@ function initSearch() {
315327}
316328
317329if (document.readyState === "complete" ||
318− (document.readyState !== "loading" && !document.documentElement.doScroll)
330+ (document.readyState !== "loading" && !document.documentElement.doScroll)
319331) {
320− initToggleSearchWindow();
321332} else {
322333 document.addEventListener("DOMContentLoaded", function () {
323334 initSearch();
@@ -326,11 +337,11 @@ if (document.readyState === "complete" ||
326337}
327338
328339// Scroll to current document in nav list.
329−let docsNavScroll = function() {
330− let docsDetails = document.querySelectorAll("nav ul details")
340+let docsNavScroll = function () {
341+ let docsDetails = document.querySelectorAll("nav ul details")
331342 for (let details in docsDetails) {
332343 if (docsDetails[details].open) docsDetails[details].scrollIntoView()
333− }
344+ }
334345}
335346
336347if (window.location.href.includes("docs")) {
@@ -348,7 +359,7 @@ if (window.location.href.includes("docs")) {
348359 // on mobile, dropdown selections go to the option
349360
350361 let docsSelect = document.getElementById('docsSelect');
351− let goTo = function() {
362+ let goTo = function () {
352363 let url = docsSelect.options[docsSelect.selectedIndex].value;
353364 if (url.startsWith("http")) {
354365 document.location.assign(url);
@@ -363,44 +374,45 @@ if (window.location.href.includes("docs")) {
363374// same-page navigation on-scroll behaviour
364375
365376if (document.body.classList.contains("page-indiced")) {
366−let h2 = document.getElementsByTagName("h2");
367−let h3 = document.getElementsByTagName("h3");
368−let all = document.querySelectorAll("nav li a");
369−let headers = document.querySelectorAll("details summary");
370−
371−// smooth scrolling on click
372−all.forEach(link => {
373− link.addEventListener("click", event => {
374− event.preventDefault();
375− let target = document.querySelector(event.target.hash);
376− target.scrollIntoView({
377− behavior: "smooth",
378− block: "start"
377+ let h2 = document.getElementsByTagName("h2");
378+ let h3 = document.getElementsByTagName("h3");
379+ let all = document.querySelectorAll("nav li a");
380+ let headers = document.querySelectorAll("details summary");
381+
382+ // smooth scrolling on click
383+ all.forEach(link => {
384+ link.addEventListener("click", event => {
385+ event.preventDefault();
386+ let target = document.querySelector(event.target.hash);
387+ target.scrollIntoView({
388+ behavior: "smooth",
389+ block: "start"
390+ });
379391 });
380392 });
381−});
382393
383−let lastId;
384−let cur = [];
394+ let lastId;
395+ let cur = [];
385396
386−window.addEventListener("scroll", event => {
387− let fromTop = window.scrollY;
397+ window.addEventListener("scroll", event => {
398+ let fromTop = window.scrollY;
388399
389− all.forEach(link => {
390− let section = document.querySelector(link.hash);
391− let sectionChildren = document.querySelector(link.hash).nextElementSibling;
400+ all.forEach(link => {
401+ let section = document.querySelector(link.hash);
402+ let sectionChildren = document.querySelector(link.hash).nextElementSibling;
392403
393− if (
394− ((section.offsetTop <= fromTop) ||
395− (sectionChildren.offsetTop <= fromTop)) &&
396− (section.offsetTop + section.offsetHeight + sectionChildren.offsetHeight > fromTop)
397− ) {
398− link.classList.add("current");
399− } else {
400− link.classList.remove("current");
401− }
402− });
403−})};
404+ if (
405+ ((section.offsetTop <= fromTop) ||
406+ (sectionChildren.offsetTop <= fromTop)) &&
407+ (section.offsetTop + section.offsetHeight + sectionChildren.offsetHeight > fromTop)
408+ ) {
409+ link.classList.add("current");
410+ } else {
411+ link.classList.remove("current");
412+ }
413+ });
414+ })
415+};
404416
405417let oceanvid = document.getElementById("ocean");
406418
templates/base.html+1−1
@@ -62,7 +62,7 @@
6262 {% block content %}
6363 {% endblock content %}
6464 {% if config.build_search_index %}
65− <script type="text/javascript" src="{{ get_url(path="runes.js") | safe }}"></script>
65+ <script type="text/javascript" src="{{ get_url(path="glossary.js") | safe }}"></script>
6666 <script type="text/javascript" src="{{ get_url(path="elasticlunr.min.js") | safe }}"></script>
6767 <script type="text/javascript" src="{{ get_url(path="search_index.en.js") | safe }}"></script>
6868 <script src="https://unpkg.com/popper.js@1"></script>
templates/essays/list.html+21−16
@@ -1,17 +1,17 @@
11{% extends "base.html" %}
22
3−{% block title %}
4− <meta name="og:title" content="Blog - {{ config.title }}">
5− <title>Blog - {{ config.title }}</title>
3+{% block title %}
4+<meta name="og:title" content="Blog - {{ config.title }}">
5+<title>Blog - {{ config.title }}</title>
66{% endblock title %}
77
8−{% block description %}
9− <meta name="og:description" content="Directory for the Urbit Blog.">
10− <meta name="description" content="Directory for the Urbit Blog.">
8+{% block description %}
9+<meta name="og:description" content="Directory for the Urbit Blog.">
10+<meta name="description" content="Directory for the Urbit Blog.">
1111{% endblock description %}
1212
1313{% block image %}
14− <meta name="twitter:image" content="https://media.urbit.org/logo/urbit-logo-card.png">
14+<meta name="twitter:image" content="https://media.urbit.org/logo/urbit-logo-card.png">
1515{% endblock image %}
1616
1717{% block content %}
@@ -25,18 +25,23 @@
2525 {% include "partials/navigation-search.html" %}
2626</nav>
2727<!-- content -->
28−<article class="mt4 mb4 c1-12 c4-12-lg">
28+<article class="mt4 mb4 c1-13 c4-12-lg">
2929 <ul class="posts measure-wide">
3030 {% set posts = get_section(path="blog/_index.md") %}
3131 {% for page in posts.pages %}
32− <li class="mb4">
33− <h2 class="f5 fw6 mt0 mb1"><a class="bb-0" href="{{ page.permalink }}">{{ page.title }}</a></h2>
34− <p class="mt0">{{ page.description }}</p>
35− <time class="mono f6">{{ page.date | date(format="~%Y.%-m.%-d") }}</time>
36− <span class="mono f6">
37− {% if page.extra.ship %}<address class="mono f6 ml2">{{ page.extra.ship }}</address> {% endif %}
38− </span>
39− </li>
32+ <a class="bb-0" href="{{ page.permalink }}">
33+ <li class="mb4">
34+ <h2 class="f5 fw6 mt0 mb1">{{ page.title }}</h2>
35+ <p class="mt0">{{ page.description }}</p>
36+ {% if page.extra.image %}
37+ <img class="pv2 obj-cover h5 w-100" src="{{ page.extra.image }}"/>
38+ {% endif %}
39+ <time class="mono f6">{{ page.date | date(format="~%Y.%-m.%-d") }}</time>
40+ <span class="mono f6">
41+ {% if page.extra.ship %}<address class="mono f6 ml2">{{ page.extra.ship }}</address> {% endif %}
42+ </span>
43+ </li>
44+ </a>
4045 {% endfor %}
4146 </ul>
4247</article>
templates/essays/post.html+5−4
@@ -1,5 +1,5 @@
11{% extends "base.html" %}
2−{% block title %}
2+{% block title %}
33 <meta name="og:title" content="{{ page.title }} - {{ config.title }}">
44 <title>{{ page.title }} - {{ config.title }}</title>
55{% endblock title %}
@@ -44,11 +44,12 @@
4444</nav>
4545
4646<article class="mb4 mt4 measure-wide full c4-12-lg">
47− <h2 class="f5 fw6 mt0 mb1">{{ page.title }}</h2>
47+ <h1 class="f5 fw6 mt0 mb1">{{ page.title }}</h1>
4848 {% if page.extra.author %}
49− <span class="dib" rel="author"> {{ page.extra.author }}
49+ <span class="db">
50+ <span class="dib fw4 mr1" rel="author">{{ page.extra.author }}</span>
5051 {% if page.extra.ship %}
51− <address class="dib fw4 ml2 mono">{{ page.extra.ship }}</address>
52+ <address class="dib gray0 fw4 mono">{{ page.extra.ship }}</address>
5253 {% endif %}
5354 </span>
5455 {% if page.date %}
templates/index.html+88−98
@@ -10,13 +10,13 @@
1010
1111{% block bodyclasses %}class="index"{% endblock bodyclasses %}
1212
13−{% block title %}
14− <meta name="og:title" content="{{ config.title }} - Your last computer">
15− <title>{{ config.title }} - Your last computer</title>
13+{% block title %}
14+ <meta name="og:title" content="{{ config.title }} - Your personal server">
15+ <title>{{ config.title }} - Your personal server</title>
1616{% endblock title %}
17−{% block description %}
18− <meta name="og:description" content="Urbit is your last computer. It's is a simple, durable computer that you own 100% and forever.">
19− <meta name="description" content="Urbit is your last computer. It's is a simple, durable computer that you own 100% and forever.">
17+{% block description %}
18+ <meta name="og:description" content="Urbit is a simple, durable system for running a personal server that you own 100% and forever.">
19+ <meta name="description" content="Urbit is a simple, durable system for running a personal server that you own 100% and forever.">
2020{% endblock description %}
2121{% block content %}
2222
@@ -30,9 +30,9 @@
3030 poster="https://media.urbit.org/site/sea30-poster.jpg">
3131 </video>
3232
33− <div class="grid12" style="height: 100%; width:100%;">
34− <div class="full c2-7-md c3-7-lg flex items-center align-center z10 white">
35− Urbit is your last computer.
33+ <div class="grid12 w-100 h-100">
34+ <div class="full c3-10-md c3-10-lg flex items-center align-center z10 white">
35+ Urbit is a clean-slate OS and network for the 21st century.
3636 </div>
3737 </div>
3838 <!-- VIMEO VERSION KEPT AS SHIM -->
@@ -41,31 +41,53 @@
4141 "></iframe> -->
4242</section>
4343
44−<!-- <nav class="full-bleed full grid12"> -->
45−
46−<section class="full c2-7-md c3-7-lg mt6">
47− <p class="lh-copy mt1 mb4">
48− Urbit is a simple, durable computer that you own 100% and forever.
49− </p>
44+<section class="full lh-copy c2-7-md c3-7-lg mt5">
45+ <p><strong>Urbit OS</strong> is a clean slate reimagining of the operating system as an 'overlay OS.' It runs on any Unix machine with an internet connection.</p>
46+ <p>It's a compact system for an individual to run their own permanent personal server.</p>
47+ <p><strong>Urbit ID</strong> is a decentralized digital identity system. Your
48+ Urbit ID is a username, network address, and crypto wallet.</p>
49+ <p>Both are designed to work together as a single system, completely <a class="b--black bb" href="https://github.com/urbit/urbit">open source</a>.</p>
50+ <ul class="list mt4">
51+ <li class="mt3">
52+ <a class="b--blue2 blue2 bb" href="/using/install/">Install + Setup</a>
53+ </li>
54+ <li class="mt3">
55+ <a class="b--green2 green2 bb" href="/docs/">Documentation</a>
56+ </li>
57+ </ul>
5058</section>
5159
52−<section class="full c2-7-md c3-7-lg mt6">
53− <ul class="list">
54− <li class="">
55− <a class="bb b--black" href="/understanding-urbit/">Introduction</a>
56− </li>
57− <li class="mt3">
58− <a class="blue2 bb b--blue" href="/docs">Docs</a>
59− </li>
60− <li class="mt3">
61− <a class="green2 bb b--green" href="/using/install">Install</a>
62− </li>
63− </ul>
60+
61+<section class="full lh-copy c7-12-md c7-11-lg mt5">
62+ <p class="fw6">Latest Posts</p>
63+ {% set s = get_section(path="updates/_index.md") %}
64+ {% set e = get_section(path="blog/_index.md") %}
65+ {% set allposts = s.pages
66+ | concat (with=e.pages)
67+ | sort(attribute="date")
68+ | reverse
69+ %}
70+ {% for page in allposts | slice (end=2) %}
71+ <a class="bb-0" href="{{ page.permalink }}">
72+ <li class="mb4 list">
73+ <h2 class="f5 fw6 mt0 mb1">{{ page.title }}</h2>
74+ {% if page.extra.image %}
75+ <img class="db pv2 obj-cover h4 w-50" src="{{ page.extra.image }}" />
76+ {% endif %}
77+ <time class="mono f6">{{ page.date | date(format="~%Y.%-m.%-d") }}</time>
78+ <span class="mono f6">
79+ {% if page.extra.ship %}
80+ <address class="mono f6 mh2">{{ page.extra.ship }}</address>
81+ {% endif %}
82+ </span>
83+ </li>
84+ </a>
85+ {% endfor %}
6486</section>
6587
66−<section class="full c2-7-md c3-7-lg mt6">
88+<section class="full c2-7-md c3-7-lg mt5">
6789 <h1 class="mb3">Understanding Urbit</h1>
68− <p class="lh-copy mt1">This sequence of posts will give you a high-level overview of Urbit. They take about 12 minutes to read.</p>
90+ <p class="lh-copy mt1">This sequence of posts will give you a high-level overview of Urbit. They take about 20 minutes to read.</p>
6991 <ul class="list">
7092 <li class="mt3">
7193 <a class="b--black bb" href="/understanding-urbit/">Introduction</a>
@@ -83,42 +105,50 @@
83105 </ul>
84106</section>
85107
86−<section class="full c7-12-md c7-11-lg mt6">
87− <h1 class="mb3">Learn More</h1>
88− <p class="lh-copy mt1">We share ongoing project developments, discuss technical considerations, and update our public roadmap as often as possible. You can follow along here.</p>
108+<section class="full c7-12-md c7-11-lg mv5">
109+ <h1 class="mb3">Stay Up to Date</h1>
110+ <p class="lh-copy mt1 mb3">
111+ We send regular updates about our project. Enter your email to get them.
112+ </p>
113+ <iframe name="nothing" style="display:none;"></iframe>
114+ <form
115+ action="https://urbit.us11.list-manage.com/subscribe/post?u=972a03db9e0c6c25bb58de8c8&amp;amp;id=be143888d2"
116+ method="post"
117+ id="mc-embedded-subscribe-form"
118+ name="mc-embedded-subscribe-form"
119+ class="validate form"
120+ target="_blank"
121+ novalidate>
122+ <div class="input-group" id="mc_embed_signup_scroll">
123+ <div class="mc-field-group w-100 relative">
124+ <input
125+ class="bg-white black b--black ba pa3 w-100 mb2 br0 wk-appearance-none"
126+ type="email"
127+ name="EMAIL"
128+ id="mce-EMAIL"
129+ placeholder="your@email.com"/>
130+ <button
131+ id="mc-embedded-subscribe"
132+ class="dib bn absolute bg-transparent"
133+ style="font-family: 'Inter UI', san-serif; right: 3px; top: 15px; -webkit-appearance: none;"
134+ type="submit"
135+ name="subscribe"
136+ onclick="_paq.push(['trackEvent', 'Mailing List', 'Subscribe'])">
137+ <span class="fr pr1">-></span>
138+ </button>
139+ </div>
140+ </div>
141+ </form>
142+ <p>You can also:</p>
89143 <ul class="list">
90144 <li class="mt3">
91− <a class="b--black bb" href="/blog/2019-10-3-roadmap/">Roadmap</a>
92− </li>
93− <li class="mt3">
94− <a class="b--black bb" href="/blog">Blog</a>
95− </li>
96− <li class="mt3">
97− <a class="b--black bb" href="/updates/">Updates</a>
98− </li>
99− <li class="mt3">
100− <a class="b--black bb" href="/media">Media</a>
101− </li>
102− <li class="mt3">
103− <a class="b--black bb" href="/faq/">FAQ</a>
104− </li>
105− </ul>
106−</section>
107−
108−<section class="full c2-7-md c3-7-lg mv6">
109− <h1 class="mb3">Follow Us</h1>
110− <p class="lh-copy mt1 mb4">Urbit is actively being built, explored, and experimented with.
111− To follow our progress you can:
112− </p>
113− <ul class="list">
114− <li class="mt2">
115145 Follow us on <a class="b--black bb" href="https://twitter.com/urbit">Twitter</a>
116146 </li>
117− <li class="mt2">
147+ <li class="mt3">
118148 Explore the code on
119149 <a class="b--black bb" href="https://github.com/urbit/urbit">GitHub</a>
120150 </li>
121− <li class="mt2">
151+ <li class="mt3">
122152 Ask questions in our <a class="b--black bb" href="https://discord.gg/Mae2bk7">Discord</a>
123153 </li>
124154 </ul>
@@ -127,45 +157,5 @@
127157 </p>
128158</section>
129159
130−<section
131− class="full c7-12-md c7-11-lg mb6 mt6-xl mt6-l mt6-m"
132− id="newsletter-subscribe-top">
133− <h1 class="mb3">Stay Up to Date</h1>
134− <p class="lh-copy mt1 mb3">
135− We send regular updates about our project. Enter your email to get them.
136− </p>
137− <iframe name="nothing" style="display:none;"></iframe>
138− <form
139− action="https://urbit.us11.list-manage.com/subscribe/post?u=972a03db9e0c6c25bb58de8c8&amp;amp;id=be143888d2"
140− method="post"
141− id="mc-embedded-subscribe-form"
142− name="mc-embedded-subscribe-form"
143− class="validate form"
144− target="_blank"
145− novalidate>
146− <div class="input-group" id="mc_embed_signup_scroll">
147− <div class="mc-field-group w-100 relative">
148− <input
149− class="bg-white black b--black ba pa3 w-100 mb2 br0 wk-appearance-none"
150− type="email"
151− name="EMAIL"
152− id="mce-EMAIL"
153− placeholder="your@email.com"/>
154− <button
155− id="mc-embedded-subscribe"
156− class="dib bn absolute bg-transparent"
157− style="font-family: 'Inter UI', san-serif; right: 3px; top: 15px; -webkit-appearance: none;"
158− type="submit"
159− name="subscribe"
160− onclick="_paq.push(['trackEvent', 'Mailing List', 'Subscribe'])">
161− <span class="fr pr1">-></span>
162− </button>
163− </div>
164− </div>
165− </form>
166−</section>
167−
168− <!-- </nav> -->
169−<!-- </article> -->
170160{% include "partials/footer.html" %}
171161{% endblock content %}
templates/list.html+4−4
@@ -1,9 +1,9 @@
11{% extends "base.html" %}
2−{% block title %}
2+{% block title %}
33 <meta name="og:title" content="{{ section.title }} - {{ config.title }}">
44 <title>{{ section.title }} - {{ config.title }}</title>
55{% endblock title %}
6−{% block description %}
6+{% block description %}
77 <meta name="og:description" content="Directory for {{ section.title }}.">
88 <meta name="description" content="Directory for {{ section.title }}.">
99{% endblock description %}
@@ -23,7 +23,7 @@
2323 {% include "partials/navigation-search.html" %}
2424</nav>
2525<!-- content -->
26−<article class="mt4 mb7 c1-12 c4-12-lg">
26+<article class="mt4 mb4 c1-13 c4-12-lg measure-wide">
2727 <ul class="posts">
2828 {% set posts = get_section(path=section.relative_path) %}
2929 {% for page in posts.pages %}
@@ -40,7 +40,7 @@
4040 <li class="mb4">
4141 <h2 class="f4 fw4 mt0 mb0"><a class="bb-0" href="{{ subsection.permalink }}">{{ subsection.title }}</a></h2>
4242 <p class="mt0">{{ subsection.description }}</p>
43− </li>
43+ </li>
4444 {% endfor %}
4545 </ul>
4646</article>
templates/media/list.html+19−17
@@ -1,10 +1,10 @@
11{% extends "base.html" %}
2−{% block title %}
2+{% block title %}
33 <meta name="og:title" content="Media - {{ config.title }}">
44 <title>Media - {{ config.title }}</title>
55{% endblock title %}
66
7−{% block description %}
7+{% block description %}
88 <meta name="og:description" content="A curated list of Urbit-related media.">
99 <meta name="description" content="A curated list of Urbit-related media.">
1010{% endblock description %}
@@ -24,13 +24,15 @@
2424 {% include "partials/navigation-search.html" %}
2525</nav>
2626<!-- content -->
27−<article class="mt4 mb4 c1-12 c4-10-lg measure-wide">
27+<article class="mt4 mb4 c1-13 c4-10-lg measure-wide">
2828 <ul class="posts">
2929 {% set posts = get_section(path="media/_index.md") %}
3030 {% for page in posts.pages %}
31− <li class="mb6">
31+ <li>
32+ <h2 class="f5 fw6 mt0 mb2"><a class="bb-0" href="{{ page.permalink }}">{{ page.title }}</a></h2>
33+
3234 {% if page.extra.youtube %}
33− <div class="video-container mb4">
35+ <div class="video-container mb2">
3436 <iframe class="w-100" height=auto
3537 src="https://www.youtube.com/embed/{{page.extra.youtube}}"
3638 webkitallowfullscreen
@@ -41,7 +43,7 @@
4143 {% endif %}
4244
4345 {% if page.extra.soundcloud %}
44− <iframe
46+ <iframe
4547 width="100%"
4648 height="300"
4749 scrolling="no"
@@ -52,20 +54,20 @@
5254 {% endif %}
5355
5456 {% if page.extra.libsyn %}
55− <iframe
56− style="border: none"
57− src="{{page.extra.libsyn}}"
58− height="90"
59− width="100%"
60− scrolling="no"
61− allowfullscreen
62− webkitallowfullscreen
63− mozallowfullscreen
64− oallowfullscreen
57+ <iframe
58+ style="border: none"
59+ src="{{page.extra.libsyn}}"
60+ height="90"
61+ width="100%"
62+ scrolling="no"
63+ allowfullscreen
64+ webkitallowfullscreen
65+ mozallowfullscreen
66+ oallowfullscreen
6567 msallowfullscreen>
6668 </iframe>
6769 {% endif %}
68− <h2 class="f5 fw6 mt0 mb1"><a class="bb-0" href="{{ page.permalink }}">{{ page.title }}</a></h2>
70+
6971 <p class="mt0">{{ page.description }}</p>
7072 <span class="mono f6">{{ page.date | date(format="~%Y.%-m.%-d") }}</span>
7173 <span class="mono f6">
templates/page.html+5−2
@@ -1,6 +1,6 @@
11{% extends "base.html" %}
22
3−{% block title %}
3+{% block title %}
44 <meta name="og:title" content="{{ page.title }} - {{ config.title }}">
55 <title>{{ page.title }} - {{ config.title }}</title>
66{% endblock title %}
@@ -22,6 +22,9 @@
2222 <meta name="twitter:image" content="https://media.urbit.org/logo/urbit-logo-card.png">
2323 {% endif %}
2424{% endblock image %}
25+{% block bodyclasses %}
26+class="essay bg-white"
27+{% endblock bodyclasses %}
2528
2629{% block content %}
2730
@@ -55,7 +58,7 @@
5558
5659{% endif %}
5760
58−<article class="mt4 mb4 c1-12 c4-10-lg">
61+<article class="mt4 mb4 c1-13 c4-12-lg measure-wide">
5962 {% if page.extra.hidetitle %} {% else %}<h1>{{ page.title }}</h1>{% endif %}
6063 {% if page.extra.author %}
6164 <span class="mt2 dib" rel="author"> {{ page.extra.author }} </span>
templates/page_indiced.html+2−2
@@ -1,7 +1,7 @@
11{% extends "base.html" %}
22{% block bodyclasses %}class="page-indiced"{% endblock bodyclasses %}
33
4−{% block title %}
4+{% block title %}
55 <meta name="og:title" content="{{ page.title }} - {{ config.title }}">
66 <title>{{ page.title }} - {{ config.title }}</title>
77{% endblock title %}
@@ -66,7 +66,7 @@
6666{% endif %}
6767{% endfor %}
6868</nav>
69− <article class="mt4 mb6 c1-12 c4-10-lg measure-wide">
69+ <article class="mt4 mb6 c1-13 c4-12-lg measure-wide">
7070 {% if page.extra.hidetitle %} {% else %}<h1>{{ page.title }}</h1>{% endif %}
7171 {% if page.extra.author %}
7272 <span class="mt2 dib" rel="author"> {{ page.extra.author }} </span>
templates/partials/footer.html+2−2
@@ -3,9 +3,9 @@
33 <nav class="c1-4-md c3-5-lg half-1 mt5">
44 <h3 class="mt0 mb3 pt0 pb0">Understanding Urbit</h3>
55 <li class="mt2 f6"><a href="/understanding-urbit">Introduction</a></li>
6+ <li class="mt2 f6"><a href="/understanding-urbit/urbit-os">Urbit OS</a></li>
67 <li class="mt2 f6"><a href="/understanding-urbit/urbit-id">Urbit ID</a></li>
7− <li class="mt2 f6"><a href="/understanding-urbit/technical-overview">Technical Overview</a></li>
8− <li class="mt2 f6"><a href="/understanding-urbit/project-history">Project Status + History</a></li>
8+ <li class="mt2 f6"><a href="/understanding-urbit/roadmap">Roadmap</a></li>
99 </nav>
1010
1111 <nav class="c4-7-md c5-7-lg half-2 mt5">
templates/partials/navigation-docs.html+56−5
@@ -1,4 +1,30 @@
11<!-- First nav is desktop-specific. Second nav is dropdown version for mobile. -->
2+
3+{% set sectionTitle = "urbit.org" %}
4+{% if page %}
5+ {% if "docs" in page.components %}
6+ {% set sectionTitle = "Docs" %}
7+ {% endif %}
8+ {% if "updates" in page.components %}
9+ {% set sectionTitle = "Updates" %}
10+ {% endif %}
11+ {% if "blog" in page.components %}
12+ {% set sectionTitle = "Blog" %}
13+ {% endif %}
14+{% endif %}
15+
16+{% if section %}
17+ {% if "docs" in section.components %}
18+ {% set sectionTitle = "Docs" %}
19+ {% endif %}
20+ {% if "updates" in section.components %}
21+ {% set sectionTitle = "Updates" %}
22+ {% endif %}
23+ {% if "blog" in section.components %}
24+ {% set sectionTitle = "Blog" %}
25+ {% endif %}
26+{% endif %}
27+
228{% block content %}
329<nav class="bg-gray5 dn db-xl pt4 full-left no-break docs pr4">
430 <a class="gray3" href="{{config.base_url}}">Urbit</a>
@@ -6,14 +32,28 @@
632 <a href="{{config.base_url}}/docs/">
733 Documentation
834 </a>
9− <button id="js-search-window-toggle" class="mt2 mb4 dn db-m db-l db-xl" type="button" style="outline:none">
10− <span id="search-icon" class="f3 gray3">⚲</span><span class="ml3 gray2">Search</span>
11− </button>
35+<button id="js-search-window-toggle" class="pointer pa0 pv3 dn db-m db-l db-xl bw-0 relative" type="button"
36+ style="outline:none">
37+ <span class="dib pv1 v-mid gray3">Search {{sectionTitle}}</span>
38+ <span class="ml1 pa1 dib v-mid ba br1 b--gray3 gray3 f7" id="keyhint">Ctrl + /</span>
39+</button>
1240 <ul class="lh-copy">
41+ <li class="ml2 mt1"><a href="/using/install">Install -> </a></li>
42+ <li class="ml2 mt1"><a href="/using/operations/">Operations Manual -></a></li>
43+ <li class="ml2 mt1 mb4"><a href="/using/develop/">Developer's Guide -></a></li>
1344 {% block menu %}
1445 {% set index = get_section(path="docs/_index.md") %}
1546 {% for s in index.subsections %}
1647 {% set subsection = get_section(path=s) %}
48+ {% if subsection.extra.nav %}
49+ <li class="ml3 mt1"><a
50+ {% if current_url == subsection.permalink %}
51+ class="fw6"
52+ {% endif %}
53+ href="{{ subsection.permalink }}">
54+ {{ subsection.title }}
55+ </a></li>
56+ {% else %}
1757 <details {% if current_url is containing(subsection.path) %}
1858 open
1959 {% endif %}
@@ -71,6 +111,7 @@
71111 {% endfor %}
72112 {% endif %}
73113 </details>
114+ {% endif %}
74115 {% endfor %}
75116 {% endblock menu %}
76117 </ul>
@@ -84,9 +125,16 @@
84125 </a>
85126 <select class="db mt4 pa2 b--black ba br0 mw4 f6 fw5" id="docsSelect" style="text-indent: 0.725rem;">
86127 <option>Navigation ↓</option>
128+ <option> </option>
129+ <option value="https://urbit.org/using/install">Install</option>
130+ <option value="https://urbit.org/using/operations/">Operations Manual</option>
131+ <option value="https://urbit.org/using/develop">Developer's Guide</option>
87132 {% set index = get_section(path="docs/_index.md") %}
88133 {% for s in index.subsections %}
89134 {% set subsection = get_section(path=s) %}
135+ {% if subsection.extra.nav %}
136+ <option value="{{ subsection.permalink }}">{{ subsection.title }}</option>
137+ {% else %}
90138 <option> </option>
91139 <option>{{ subsection.title }}</option>
92140 <option>---</option>
@@ -117,10 +165,13 @@
117165 {% endif %}
118166 {% endfor %}
119167 {% endif %}
168+ {% endif %}
120169 {% endfor %}
121170 </select>
122− <button id="js-search-window-toggle" class="mt4 mb4 dn db-m db-l db-xl" type="button" style="outline:none">
123− <span id="search-icon" class="f3 gray3">⚲</span><span class="ml3 gray2">Search</span>
171+ <button id="js-search-window-toggle" class="pointer pa0 pt3 dn db-m db-l db-xl bw-0 relative" type="button"
172+ style="outline:none">
173+ <span class="pv1 dib v-mid gray3">Search {{sectionTitle}}</span>
174+ <span class="ml1 pa1 dib v-mid ba br1 b--gray3 gray3 f7" id="keyhint">Ctrl + /</span>
124175 </button>
125176</nav>
126177{% endblock content %}
templates/partials/navigation-search.html+28−3
@@ -1,4 +1,29 @@
1−<button id="js-search-window-toggle" class="pointer mt2 dn db-m db-l db-xl bw-0 mb3" type="button" style="outline:none">
2− <span id="search-icon" class="f3 gray3">⚲</span>
3− <span class="gray3">Search</span>
1+{% set sectionTitle = "urbit.org" %}
2+{% if page %}
3+ {% if "docs" in page.components %}
4+ {% set sectionTitle = "Docs" %}
5+ {% endif %}
6+ {% if "updates" in page.components %}
7+ {% set sectionTitle = "Updates" %}
8+ {% endif %}
9+ {% if "blog" in page.components %}
10+ {% set sectionTitle = "Blog" %}
11+ {% endif %}
12+{% endif %}
13+
14+{% if section %}
15+ {% if "docs" in section.components %}
16+ {% set sectionTitle = "Docs" %}
17+ {% endif %}
18+ {% if "updates" in section.components %}
19+ {% set sectionTitle = "Updates" %}
20+ {% endif %}
21+ {% if "blog" in section.components %}
22+ {% set sectionTitle = "Blog" %}
23+ {% endif %}
24+{% endif %}
25+
26+<button id="js-search-window-toggle" class="pointer pa0 pt3 mb3 dn db-m db-l db-xl bw-0 relative" type="button" style="outline:none">
27+ <span class="pv1 dib v-mid gray3">Search {{sectionTitle}}</span>
28+ <span class="ml1 pa1 dib v-mid ba br1 b--gray3 gray3 f7" id="keyhint">Ctrl + /</span>
429</button>
templates/partials/pagination.html+14−14
@@ -1,26 +1,26 @@
1−<footer class="relative mt4 mb4">{% if page.earlier %}
1+<footer class="relative measure-wide">{% if page.earlier %}
22 <a class="bb-0" href="{{page.earlier.permalink}}">
3− <nav class="previous absolute right-1 t-right mb4">
3+ <nav class="previous absolute right-1 t-right">
44 {% if page.extra.hide_previous_title %} {% else %}<p class="mb0 f5">Previous Post:</p>{% endif %}
55 <p {% if page.extra.flatten_pagination %}
66 data-flat="true"
7− class="mt5 mb5
7+ class="mt5 relative mb5
88 {% else %}
99 class="mt0 mb0 fw6 f5
1010 {% endif %}
1111 ">{{page.earlier.title}}</p>
12− <time class="mono db f5 mb5">{{page.earlier.date | date(format="~%Y.%-m.%-d") }}</time>
12+ <time class="gray2 mono db f5 mb4">{{page.earlier.date | date(format="~%Y.%-m.%-d") }}</time>
1313 </nav>
1414 </a>
1515
1616 {% elif page.heavier and not page.extra.hidenext %}
1717
1818 <a class="bb-0" href="{{page.heavier.permalink}}">
19− <nav class="previous absolute right-1 t-right mb4">
19+ <nav class="previous absolute right-1 t-right">
2020 {% if page.extra.hide_next_title %} {% else %}<p class="mb0 f5">Next Post:</p>{% endif %}
2121 <p {% if page.extra.flatten_pagination %}
2222 data-flat="true"
23− class="mt5 mb5
23+ class="mt5 relative mb5
2424 {% else %}
2525 class="mt0 mb0 fw6 f5
2626 {% endif %}
@@ -29,12 +29,12 @@
2929 </a>
3030 {% endif %}
3131
32− {% if page.relative_path == "understanding-urbit/simple-durable-yours.md" %}
32+ {% if page.relative_path == "understanding-urbit/urbit-os.md" %}
3333 <a class="bb-0" href="/understanding-urbit/">
34− <nav class="next absolute left-1 t-left mb4">
34+ <nav class="next absolute left-1 t-left">
3535 <p {% if page.extra.flatten_pagination %}
3636 data-flat="true"
37− class="mt5 mb5
37+ class="mt5 relative mb5
3838 {% else %}
3939 class="mt0 mb0 fw6 f5
4040 {% endif %}
@@ -44,16 +44,16 @@
4444 {% elif page.later %}
4545
4646 <a class="bb-0" href="{{page.later.permalink}}">
47− <nav class="next absolute left-1 mb4">
47+ <nav class="next absolute left-1">
4848 {% if page.extra.hide_next_title %} {% else %}<p class="mb0 f5">Next Post:</p>{% endif %}
4949 <p {% if page.extra.flatten_pagination %}
5050 data-flat="true"
51− class="mt5 mb5
51+ class="mt5 relative mb5
5252 {% else %}
5353 class="mt0 mb0 fw6 f5
5454 {% endif %}
5555 ">{{page.later.title}}</p>
56− <time class="mono db f5 mb5">{{page.later.date | date(format="~%Y.%-m.%-d") }}</time>
56+ <time class="gray2 mono db f5 mb4">{{page.later.date | date(format="~%Y.%-m.%-d") }}</time>
5757 </nav>
5858 </a>
5959
@@ -61,11 +61,11 @@
6161 {% elif page.lighter and not page.extra.hideprevious %}
6262
6363 <a class="bb-0" href="{{page.lighter.permalink}}">
64− <nav class="next absolute left-1 mb4">
64+ <nav class="next absolute left-1">
6565 {% if page.extra.hide_previous_title %} {% else %}<p class="mb0 f5">Previous Post:</p>{% endif %}
6666 <p {% if page.extra.flatten_pagination %}
6767 data-flat="true"
68− class="mt5 mb5
68+ class="mt5 relative mb5
6969 {% else %}
7070 class="mt0 mb0 fw6 f5
7171 {% endif %}
templates/partials/search-overlay.html+2−2
@@ -9,8 +9,8 @@
99 </div>
1010 <div id="full-results">
1111 <div id="glossary-results" class="glossary-results bt b--gray3 w-100">
12− <div class="glossary-results__header mv1 gray3 f6">
13− <div class="glossary-results__item">
12+ <div class="glossary-results__header gray3 f6">
13+ <div class="glossary-results__item pa3">
1414 </div>
1515 </div>
1616 </div>
templates/sections/docs/glossary.htmlnew file+57
@@ -0,0 +1,57 @@
1+{% extends "base.html" %}
2+{% block title %}
3+ <meta name="og:title" content="{{ section.title }} - {{ config.title }}">
4+ <title>{{ section.title }} - {{ config.title }}</title>
5+{% endblock title %}
6+
7+{% block description %}
8+ <meta name="og:description" content="From the Urbit documentation.">
9+ <meta name="description" content="From the Urbit documentation.">
10+{% endblock description %}
11+
12+{% block image %}
13+ <meta name="twitter:image" content="https://media.urbit.org/logo/urbit-logo-card.png">
14+{% endblock image %}
15+
16+{% block content %}
17+<!-- header -->
18+<!-- content -->
19+{% include "partials/navigation-docs.html" %}
20+<article class="mt4 mb6 full c4-11-lg">
21+<!-- header -->
22+<h1>{{ section.title }}</h1>
23+<!-- body -->
24+
25+<div class="measure-wide mb4">
26+{{ section.content | safe }}
27+
28+</div>
29+
30+{% set terms = get_section(path="docs/glossary/_index.md") %}
31+{% set arvoTerms = terms.pages | filter(attribute="extra.category", value="arvo") | sort(attribute="title") %}
32+{% set azimuthTerms = terms.pages | filter(attribute="extra.category", value="azimuth") | sort(attribute="title") %}
33+{% set hoonNockTerms = terms.pages | filter(attribute="extra.category", value="hoon-nock") | sort(attribute="title") %}
34+<div class="flex flex-wrap justify-between">
35+ <div class="mt0 w-100 w-50-l w-30-xl"><a class="fw6" href="/docs/glossary/arvo/">Arvo</a>
36+ <p>The Urbit OS.</p>
37+ {% for term in arvoTerms %}
38+ <li class="list mb1 ml0 mt1"><a href="{{term.permalink}}">{{ term.title }}</a></li>
39+ {% endfor %}
40+ </div>
41+ <div class="mt4 mt0-l mt0-xl w-100 w-50-l w-30-xl">
42+ <a class="fw6" href="/docs/glossary/azimuth">Azimuth</a>
43+ <p>The Urbit identity layer.</p>
44+ {% for term in azimuthTerms %}
45+ <li class="list mb1 ml0 mt1"><a href="{{term.permalink}}">{{ term.title }}</a></li>
46+ {% endfor %}
47+ </div>
48+
49+ <div class="mt4 mt0-l mt0-xl w-100 w-50-l w-40-xl">
50+ <a class="fw6" href="/docs/glossary/hoon">Hoon</a> <span class="fw6">+</span> <a class="fw6" href="/docs/glossary/nock">Nock</a>
51+ <p>Hoon is Urbit's high-level programming language. It compiles to Nock, Urbit's low-level language.</p>
52+ {% for term in hoonNockTerms %}
53+ <li class="list mb1 ml0 mt1"><a href="{{term.permalink}}">{{ term.title }}</a></li>
54+ {% endfor %}
55+ </div>
56+</div>
57+{% endblock content %}
templates/sections/docs/hoon.htmlnew file+52
@@ -0,0 +1,52 @@
1+{% extends "base.html" %}
2+{% block title %}
3+ <meta name="og:title" content="{{ section.title }} - {{ config.title }}">
4+ <title>{{ section.title }} - {{ config.title }}</title>
5+{% endblock title %}
6+
7+{% block description %}
8+ <meta name="og:description" content="From the Urbit documentation.">
9+ <meta name="description" content="From the Urbit documentation.">
10+{% endblock description %}
11+
12+{% block image %}
13+ <meta name="twitter:image" content="https://media.urbit.org/logo/urbit-logo-card.png">
14+{% endblock image %}
15+
16+{% block content %}
17+<!-- header -->
18+<!-- content -->
19+{% include "partials/navigation-docs.html" %}
20+<article class="mt4 mb6 full c4-11-lg">
21+<!-- header -->
22+<h1>{{ section.title }}</h1>
23+<!-- body -->
24+
25+<div class="measure-wide mb4">
26+{{ section.content | safe }}
27+
28+{% set lessons = get_section(path="docs/tutorials/hoon/_index.md") %}
29+
30+<ul>
31+ <h2 class="mv4">Chapter 1</h2>
32+{% for lesson in lessons.pages %}
33+ {% if lesson.title is starting_with("1") %}
34+ <li><a href="{{lesson.permalink}}">{{lesson.title}}</a></li>
35+ {% endif %}
36+{% endfor %}
37+ <h2 class="mv4">Chapter 2</h2>
38+ {% for lesson in lessons.pages %}
39+ {% if lesson.title is starting_with("2") %}
40+ <li><a href="{{lesson.permalink}}">{{lesson.title}}</a></li>
41+ {% endif %}
42+{% endfor %}
43+
44+<br/>
45+{% for lesson in lessons.pages %}
46+ {% if (lesson.title is not starting_with("2")) and (lesson.title is not starting_with("1")) %}
47+ <li><a href="{{lesson.permalink}}">{{lesson.title}}</a></li>
48+ {% endif %}
49+{% endfor %}
50+</ul>
51+</div>
52+{% endblock content %}
templates/understanding-urbit/list.html+73−79
@@ -32,91 +32,85 @@
3232
3333</nav>
3434<!-- content -->
35−<h1 id="introduction" class="mb4 full mt4 c4-10-lg">Introduction</h1>
36−<section class="full-bleed full grid12">
37− <img class="full c4-10-lg mb4" src="https://storage.googleapis.com/media.urbit.org/site/understanding-urbit/intro/intro-0.jpg"/>
38− <p class="full c4-10-lg mt0 mb4 mb4-xl lh-copy">
39− Imagine that you can login from anywhere with one name and password.
40− </p>
41− <p class="full c4-10-lg mt0 mb4 mb4-xl lh-copy">
42− And when you do, your entire OS appears.
43− </p>
44− <p class="full c4-10-lg mt0 mb4 mb4-xl lh-copy">
45− Inside is your whole digital life. All of your communities, conversations, and connections. All of your biometric data and devices. Your entire personal archive in one place that’s secure, private, and designed to last forever.
46− </p>
47− <p class="full c4-10-lg mt0 mb4 mb4-xl lh-copy">
48− You own and control this OS completely. It’s yours. No one else can look at it without your permission, it can never show you ads.
49− </p>
50− <p class="full c4-10-lg mt0 mb4 mb4-xl lh-copy">
51− This is what Urbit is. Your Urbit is a simple, durable computer that belongs to you 100% and forever.
52− </p>
53− <p class="full c4-10-lg mt0 mb4 mb4-xl lh-copy">
54− Urbit is not vaporware. It's real and it works. Two separate companies and a community of contributors are working together to build the Urbit future.
55− </p>
56− <p class="full c4-10-lg mt0 mb4 mb4-xl lh-copy">
57− But Urbit isn't ready for everyone yet. Today, it's a version <code>0</code>. Brave explorers should find a way in. In 2020, we plan to open Urbit for more people.
58− </p>
59− <p class="full c4-10-lg mt0 mb8 mb7-xl lh-copy">
60− Let’s walk through what Urbit is, what it’s for and where we’re going step by step.
61− </p>
35+<section class="full c4-12-lg measure-wide">
36+ <h1 id="introduction" class="mb4 full mt4 ">Introduction</h1>
37+ <p class="full mt0 mb4 mb4-xl lh-copy">We think the internet can’t be saved. The way things are going, MEGACORP will always control our apps and services because we can no longer run them ourselves.</p>
38+ <p class="full mt0 mb4 mb4-xl lh-copy">The only way out of this mess is with a completely new platform that’s owned and controlled by its users.</p>
39+ <img class="full ba mb4" src="https://storage.googleapis.com/media.urbit.org/site/understanding-urbit/intro/intro-0.jpg"/>
40+ <p class="full mt0 mb4 mb4-xl lh-copy">Urbit is a new OS and peer-to-peer network that’s simple by design, built to last forever, and 100% owned by its users. Under the hood, Urbit is a clean-slate software stack compact enough that an individual developer can understand and control it completely.</p>
41+ <p class="full mt0 mb4 mb4-xl lh-copy">We built this new stack to give people a single integrated tool for communicating and building communities – a tool they can trust, control, and extend to their liking. We want to do away with the terrible user experience of the current ‘frankenstack’ of apps and services that we all use today. </p>
42+ <p class="full mt0 mb4 mb4-xl lh-copy">Urbit is designed to become an effective, customizable productivity tool for collaborators, and a calm noninvasive communication tool for friends and families.</p>
43+ <p class="full mt0 mb4 mb4-xl lh-copy">This probably sounds crazy, so let’s get concrete and talk about (1) Urbit as a piece of technology and (2) Urbit as a user experience.</p>
44+ <p class="full mt0 mb4 mb4-xl lh-copy b">1 - Technology</p>
45+ <p class="full mt0 mb4 mb4-xl lh-copy">Technically, Urbit is two components: Urbit OS and Urbit ID.</p>
46+ <p class="full mt0 mb4 mb4-xl lh-copy">Both are completely <a class="bb" href="https://github.com/urbit/urbit">open</a> <a class="bb" href="https://github.com/urbit/azimuth">source</a> and MIT licensed.</p>
47+ <img class="full w-100 mb4" src="https://media.urbit.org/site/understanding-urbit/uu-intro-2.svg"/>
48+ <p class="full mt0 mb4 mb4-xl lh-copy">Urbit OS is a new, carefully architected software stack: a VM, programming language and kernel designed to run software for an individual. </p>
49+ <p class="full mt0 mb4 mb4-xl lh-copy">Urbit OS is a program that runs on almost any cloud server, most laptops and many phones: anything with Unix and an internet connection. Urbit OS is completely sealed from the system it runs on, sort of like WASM or the JVM. We sometimes call it an ‘overlay OS’.</p>
50+ <p class="full mt0 mb4 mb4-xl lh-copy">In an Urbit world, each person has their own Urbit OS node, or ‘urbit’. Your urbit is secure and private to you and entirely under your control. When you want to connect with others, you connect to their urbit directly — rather than going through a centralized service. </p>
51+ <p class="full mt0 mb4 mb4-xl lh-copy">If you’re curious to dive even deeper into Urbit OS, feel free to <a class="bb" href="/understanding-urbit/urbit-os">skip ahead</a>.</p>
52+ <img class="full w-100 mb4" src="https://media.urbit.org/site/understanding-urbit/uu-intro-3.svg"/>
53+ <p class="full mt0 mb4 mb4-xl lh-copy">Urbit ID is an identity and authentication system specifically designed to work with Urbit OS. When you boot or log in to Urbit OS, you use your Urbit ID. </p>
54+ <p class="full mt0 mb4 mb4-xl lh-copy">Your Urbit ID is a short, memorable name (like <code>~ravmel-ropdyl</code>) that’s a username, network address and crypto wallet all in one. It’s registered on a blockchain, you own it with a key and no one can take it away from you. Urbit IDs are cryptographic property. </p>
55+ <p class="full mt0 mb4 mb4-xl lh-copy">Urbit IDs aren’t money, but they are scarce, so each one costs something. This means that when you meet a stranger on the Urbit network, they have some skin in the game and are less likely to be a bot or a spammer.</p>
56+ <p class="full mt0 mb4 mb4-xl lh-copy">The Urbit ID system is live and deployed, and we don’t plan to change it all that much. It works well. If you’re curious to dive further into the details, jump ahead to <a class="bb" href="/understanding-urbit/urbit-id">this post.</a></p>
57+ <p class="full mt0 mb4 mb4-xl lh-copy b">2 - User experience</p>
58+ <p class="full mt0 mb4 mb4-xl lh-copy">We want Urbit to be a single, simple interface for your whole digital life.</p>
59+ <img class="full ba mb4" src="https://media.urbit.org/site/understanding-urbit/uu-intro-4.png"/>
60+ <p class="full mt0 mb4 mb4-xl lh-copy">Over the years, Urbit has been built in public as an open source project. Anyone can <a class="bb" href="/using/install/">join the network</a> and check out what we’re up to. It’s a bit like signing on to IRC in the early 90s. </p>
61+ <p class="full mt0 mb4 mb4-xl lh-copy">In early 2020, we’ll release Urbit OS 1: a minimal interface for group communication, and our first complete interface. OS 1 is a tool to chat, share notes and links, and stay connected. </p>
62+ <p class="full mt0 mb4 mb4-xl lh-copy">OS 1 is the first step toward a truly complete OS for a networked world. </p>
63+ <p class="full mt0 mb4 mb4-xl lh-copy">Over time, Urbit will grow into a system that can bring together all our different modes of communicating: chat, payments, documents, images, biometric data. We want individuals and their communities to be able to both control their software in fact, through the source code, and in action, through a simple interface.</p>
64+ <p class="full mt0 mb4 mb4-xl lh-copy">We want to leave behind a world of apps and services for one where we can bring everything together in one place. And, in doing so, ordinary users can create customized digital environments for their friends and communities.</p>
65+ <img class="full ba mb4" src="https://storage.googleapis.com/media.urbit.org/site/understanding-urbit/intro/intro-6.jpg"/>
66+ <p class="full mt0 mb4 mb4-xl lh-copy">To see how we’re going to get there, let’s walk through these two pieces of new technology individually, Urbit OS and Urbit ID. We’ll then talk about our vision for the future and how we’ll get there.</p>
67+ <p class="full mt0 mb4 mb4-xl lh-copy">For technical people, it’s important to note that Urbit as a stack is in no way required to be used together. Don’t like our client? Feel free to build your own. Just like the Urbit ID system? No problem — use it!
68+ <p class="full mt0 mb4 mb4-xl lh-copy">Ultimately, we think that new technology is most likely to get adopted if it can provide a much, much better user experience. So that’s what we’re focussing on creating.</p>
6269</section>
63−<section class="full-bleed full grid12 mt7">
64− <p class="full c4-7-lg mt0 mb4 mb2-xl lh-copy">
65− This is a drawing of an Urbit&nbsp;—&nbsp; a new kind of computer. <br /><br />
66− Your Urbit isn’t a physical device: it lives in the cloud or your laptop.
67− </p>
68− <img class="full c7-10-lg row-1 mt0 mb2 mb4-xl w-100 ba" src="https://storage.googleapis.com/media.urbit.org/site/understanding-urbit/intro/intro-1.svg" alt="A drawing of an Urbit ship." />
69−</section>
70−<section class="full-bleed full grid12">
71− <p class="full c4-7-lg mt0 mb4 mb2-xl lh-copy">
72− Your Urbit is a tool for you to run your own social software to connect and communicate with your friends and family. <br /><br />
73− Urbit is the opposite of MEGACORP social media.
74− </p>
75− <img class="full c7-10-lg row-1 mt0 mb2 mb4-xl w-100 ba" src="https://storage.googleapis.com/media.urbit.org/site/understanding-urbit/intro/intro-2.svg" alt="An Urbit ship receiving data." />
76−</section>
77−<section class="full-bleed full grid12">
78− <p class="full c4-7-lg mt0 mb4 mb2-xl lh-copy">
79− Your Urbit is a permanent, private archive.<br /><br />
80− Your Urbit can store all your data and digital assets safely, privately, forever.
81− </p>
82− <img class="full c7-10-lg row-1 mt0 mb2 mb4-xl w-100 ba" src="https://storage.googleapis.com/media.urbit.org/site/understanding-urbit/intro/intro-3.svg" alt="An Urbit ship with its previous versions in a lifetime archive" />
83−</section>
84−<section class="full-bleed full grid12">
85− <p class="full c4-7-lg mt0 mb6 mb2-xl lh-copy">
86− You own your Urbit like you own Bitcoin.<br /><br />
87− Each Urbit is a piece of a new network that’s owned and controlled by its users.
88− </p>
89− <img class="full c7-10-lg row-1 mt0 mb2 mb7-xl w-100 ba" src="https://storage.googleapis.com/media.urbit.org/site/understanding-urbit/intro/intro-4.svg" alt="An Urbit ship communicating with other ships" />
90−</section>
91−<section id="megacorp" class="full full-bleed grid12 bg-black">
92− <img class="full c4-10-lg mt7" src="https://storage.googleapis.com/media.urbit.org/site/understanding-urbit/intro/intro-5.jpg"/>
93− <p class="full c4-10-lg white lh-copy mt2 mt4-xl mb7">
94− Today, technology controls us. Every MEGACORP has the same incentive: To keep us hooked on their platform.
95− </p>
96−</section>
97−<section class="full full-bleed grid12 bg-yellow">
98− <img class="full c4-10-lg mt7" src="https://storage.googleapis.com/media.urbit.org/site/understanding-urbit/intro/intro-6.jpg"/>
99− <p class="full c4-10-lg lh-copy mt2 mt4-xl">
100− We built Urbit so people can control their technology, shape their digital lives and freely build their digital communities.
101− </p>
102− <p class="full c4-10-lg lh-copy mt2">
103− We want to replace the Internet with a foundation for computing that we can all rely on far into the future.
104− </p>
105− <p class="full c4-10-lg lh-copy mt2">
106− Urbit is a large, ambitious project. But at the core it’s simple, durable and yours.
107− </p>
108−</section>
109−<p class="c1-10 c4-10-lg mt6 mb4 lh-copy">
110− Nothing quite like this has ever been done before.
111−</p>
112−<footer class="relative mt4 c4-10-lg full">
70+
71+<footer class="relative mt4 c4-12-lg full measure-wide">
11372 {% set posts = get_section(path="understanding-urbit/_index.md") %}
11473 {% for directorypage in posts.pages | slice (end=1) %}
115− <a class="bb-0" href="{{directorypage.permalink}}">
74+ <a href="{{directorypage.permalink}}">
11675 <nav class="previous absolute right-2 t-right">
117− <p data-flat="true" class="mt5 mb6">{{directorypage.title}}</p>
76+ <p data-flat="true" class="mt5 relative mb6">{{directorypage.title}}</p>
11877 </nav>
11978 </a>
12079 {% endfor %}
12180</footer>
81+
82+<section class="full c4-12-lg lh-copy mt6 mb4 measure-wide">
83+ <iframe name="nothing" style="display:none;"></iframe>
84+ <p class="mt5">If you’d like to follow our progress, we send monthly updates via email:</p>
85+ <form
86+ action="https://urbit.us11.list-manage.com/subscribe/post?u=972a03db9e0c6c25bb58de8c8&amp;amp;id=be143888d2"
87+ method="post"
88+ id="mc-embedded-subscribe-form"
89+ name="mc-embedded-subscribe-form"
90+ class="validate form"
91+ target="_blank"
92+ novalidate>
93+ <div class="input-group" id="mc_embed_signup_scroll">
94+ <div class="mc-field-group w-100 relative">
95+ <input
96+ class="bg-white black b--black ba pa3 w-100 mb2 br0 wk-appearance-none"
97+ type="email"
98+ name="EMAIL"
99+ id="mce-EMAIL"
100+ placeholder="your@email.com"/>
101+ <button
102+ id="mc-embedded-subscribe"
103+ class="dib bn absolute bg-transparent"
104+ style="font-family: 'Inter UI', san-serif; right: 3px; top: 15px; -webkit-appearance: none;"
105+ type="submit"
106+ name="subscribe"
107+ onclick="_paq.push(['trackEvent', 'Mailing List', 'Subscribe'])">
108+ <span class="fr pr1">-></span>
109+ </button>
110+ </div>
111+ </div>
112+ </form>
113+ <p class="mt3 mb3 mb3-xl lh-copy">You can also follow us on <a class="bb" href="https://twitter.com/urbit">Twitter</a> or <a class="bb" href="https://github.com/urbit">Github</a>.</p>
114+ <p class="mt0 mb3 mb4-xl lh-copy">Or, preferably, on Urbit itself in <code>~dopzod/urbit-help</code></p>
115+</section>
122116{% endblock content %}
templates/understanding-urbit/post.html+37−3
@@ -1,6 +1,6 @@
11{% extends "base.html" %}
22
3−{% block title %}
3+{% block title %}
44 <meta name="og:title" content="{{ page.title }} - {{ config.title }}">
55 <title>{{ page.title }} - {{ config.title }}</title>
66{% endblock title %}
@@ -53,7 +53,7 @@
5353 {% endfor %}
5454</nav>
5555
56− <article class="mb4 full c4-12-lg measure-wide">
56+ <article class="full c4-12-lg measure-wide">
5757 <h1 class="mb4 mt4">{{ page.title }}</h1>
5858 {% if page.extra.author %}
5959 <span class="dib" rel="author"> {{ page.extra.author }}
@@ -68,9 +68,43 @@
6868 {% if page.extra.readtime %}
6969 <span class="dib mono{% if page.date %} ml2{% endif %} gray2 f5">{{ page.reading_time }}m read</span>
7070 {% endif %}
71−
71+
7272 {{ page.content | safe }}
7373
7474 {% include "partials/pagination.html" %}
7575 </article>
76+ <section class="full c4-12-lg lh-copy mt6 mb4 measure-wide">
77+ <iframe name="nothing" style="display:none;"></iframe>
78+ <p class="mt5">If you’d like to follow our progress, we send monthly updates via email:</p>
79+ <form
80+ action="https://urbit.us11.list-manage.com/subscribe/post?u=972a03db9e0c6c25bb58de8c8&amp;amp;id=be143888d2"
81+ method="post"
82+ id="mc-embedded-subscribe-form"
83+ name="mc-embedded-subscribe-form"
84+ class="validate form"
85+ target="_blank"
86+ novalidate>
87+ <div class="input-group" id="mc_embed_signup_scroll">
88+ <div class="mc-field-group w-100 relative">
89+ <input
90+ class="bg-white black b--black ba pa3 w-100 mb2 br0 wk-appearance-none"
91+ type="email"
92+ name="EMAIL"
93+ id="mce-EMAIL"
94+ placeholder="your@email.com"/>
95+ <button
96+ id="mc-embedded-subscribe"
97+ class="dib bn absolute bg-transparent"
98+ style="font-family: 'Inter UI', san-serif; right: 3px; top: 15px; -webkit-appearance: none;"
99+ type="submit"
100+ name="subscribe"
101+ onclick="_paq.push(['trackEvent', 'Mailing List', 'Subscribe'])">
102+ <span class="fr pr1">-></span>
103+ </button>
104+ </div>
105+ </div>
106+ </form>
107+ <p class="mt3 mb3 mb3-xl lh-copy">You can also follow us on <a class="bb" href="https://twitter.com/urbit">Twitter</a> or <a class="bb" href="https://github.com/urbit">Github</a>.</p>
108+ <p class="mt0 mb3 mb4-xl lh-copy">Or, preferably, on Urbit itself in <code>~dopzod/urbit-help</code></p>
109+ </section>
76110{% endblock content %}
templates/updates/list.html+5−8
@@ -1,10 +1,10 @@
11{% extends "base.html" %}
2−{% block title %}
2+{% block title %}
33 <meta name="og:title" content="Updates - {{ config.title }}">
44 <title>Updates - {{ config.title }}</title>
55{% endblock title %}
66
7−{% block description %}
7+{% block description %}
88 <meta name="og:description" content="Updates on the Urbit project.">
99 <meta name="description" content="Updates on the Urbit project.">
1010{% endblock description %}
@@ -26,7 +26,7 @@
2626 {% include "partials/navigation-search.html" %}
2727</nav>
2828<!-- content -->
29−<main class="mt4 mb4 c1-12 c4-10-lg measure-wide">
29+<main class="mt4 mb4 c1-13 c4-12-lg measure-wide">
3030
3131 {% set posts = get_section(path="updates/_index.md") %}
3232
@@ -49,12 +49,9 @@
4949
5050 {% endfor %}
5151 <h2 id="more-updates" class="mt5 mb3">More Updates</h2>
52− <ul class="posts">
52+ <ul class="posts update">
5353 {% for page in posts.pages | slice (start=1) %}
54− <li class="mb4 mt4">
55− <!-- <h2 class="f5 fw6">
56− <a class="bb0" href="{{ page.permalink }}">{{ page.title }}</a>
57− </h2> -->
54+ <li>
5855 <a class="bb0" href="{{ page.permalink }}">
5956 <p class="mv2">{{ page.description }}</p>
6057 </a>