first round of content

content/community.md

@@ -0,0 +1,60 @@
++++
+title: Community
++++
+
+The developer community is a combination of top-down stewardship from the Urbit Foundation and Tlon, as well as organic, bottom-up coordination from unaffiliated enthusiasts.
+
+The Forge is a community-run Landscape group (~middev/the-forge) focused on all things related to Urbit development. Its members consist of enthusiasts, Tlon and Foundation developers, and grant workers. It’s also a great repository of community-compiled knowledge of common issues and development techniques.
+
+The Urbit Foundation makes direct investments of address space into the community as a means of improving the network. The Foundation also maintains developer documentation, runs Developer Calls, and acts as the hub of the Urbit ecosystem. You can find us hanging around in the Foundation group in Landscape (~wolref-podlex/foundation).
+
+Tlon is the primary developer of Urbit itself and the foremost product developer within the Urbit ecosystem. They’ve been developing Urbit since 2013 and are naturally a great source of information. They maintain the most popular Landscape groups, Urbit Community (~bitbex-bolbel/urbit-community) and Urbit Index (~todo-todo/urbit-index).
+
+Directory
+Our community is comprised of individuals, all of whom happen to be pretty friendly. Here’s a list of prominent figures you’ll likely encounter that are open to being contacted:
+
+~wolref-podlex
+Executive Director, Urbit Foundation
+Partnerships, grants, employment opportunities, technical projects, Urbit Foundation
+
+~ravmel-ropdyl
+CEO, Tlon
+Partnerships, employment opportunities, geodesic domes, future of Urbit
+
+~timluc-miptev
+Technical Director, Urbit Foundation
+Userspace development, grants
+
+~lagrev-nocfep
+Technical Director, Urbit Foundation
+Urbit education
+
+~poldec-tonteg
+Program Manager, The Combine
+Urbit entrepreneurship, organizational grants
+
+~tirwyd-sarmes
+Content Manager, Urbit Foundation
+Content grants, newsletter, blog
+
+~taller-ravnut
+Developer Relations, Urbit Foundation
+Grants, meetups, gifts, Developer Calls
+
+~tinnus-napbus
+Technical writer and mentor, Urbit Foundation
+Developer documentation, developer support
+
+~wicdev-wisryt
+CTO, Tlon
+Infrastructure development, Arvo, apprenticeships
+
+~master-morzod
+Senior infrastructure engineer, Tlon
+Infrastructure development, Vere, Arvo
+
+~rovnys-ricfer
+Senior infrastructure engineer, Tlon
+Infrastructure development, Arvo, software distribution
+
+~palfun-foslup, ~littel-wolfur, ~lavlyn-litmeg, ~mocrux-nomdep, ~sicdev-pilnup, etc.

content/learn.md

@@ -0,0 +1,47 @@
++++
+title: Learn
++++
+
+We’ve made several self-guided tutorials and guides available to get your started on your journey, which should be read in order. All-in-all, a programmer with some experience should be able to work through this material and become proficient at Urbit programming in under a month of regular study.
+
+## Urbit 101
+
+### Environment Setup Guide (~1 hour)
+
+This guide contains the best practices for configuring your environment for Urbit development, like setting up your text editor and working with “fakeships”. This guide also serves as a reference for environment-related issues.
+
+### Hoon Tutorial (~1-2 weeks)
+
+This is the recommended starting point for anyone that wants to learn full stack Urbit development. It walks you through the Hoon programming language, generators, and the basics of Urbit programming.
+
+### Gall Tutorial (~1-2 weeks)
+
+This course picks up where Hoon School left off by teaching you how to use the language to build a real-world application using a gall agent. This covers the entirety of the gall API, best practices for developing agents over time, and exercises to push your knowledge.
+
+### Client-side Integration Guide (~1 day)
+
+The vane eyre allows clients to interact with Urbit over an HTTP interface. Urbit’s architecture is organized around command query responsibility segregation (CQRS), which makes heavy use of pub/sub patterns. Working with this API is different than more typical request/response architecture, and this guide gives you a comprehensive overview of how to do so.
+
+## Urbit 201
+
+Equipped with knowledge of the basics of all parts of the stack, there are a number of additional supplementary tutorials and guides to deepen your knowledge:
+
+### Guide to Working with JSON
+
+JSON is a dynamically-defined datastructure, and Hoon is a statically-typed language, which means that the two don’t play together really well. This guide gives a comprehensive overview of how to parse and serialize JSON from Hoon.
+
+### Software Distribution Guide
+
+After you’ve created something on Urbit you’ll probably want to share it with other people. This guide walks you through the mechanisms for distributing software over the network.
+
+### Fullstack Development Tutorial: TodoMVC
+
+This tutorial walks you though everthing you’ve learned to date: writing a gall agent in Hoon from scratch, adapting the classic TodoMVC frontend to interface with that gall agent, and then package up the entire application for distribution over the network.
+
+### Graph Store Tutorial
+
+Graph store is a gall agent that’s designed to be a general-purpose database for storing graph-like data. Comprising the bulk of the backend for Tlon’s Landscape applciation, it’s battle tested and optimized for real-world use. This guide walks you through its architecture and implementation, and then shows you how to use it as a data store for your own application.
+
+### Guide to Threads
+
+TODO: Maybe this is better for 101?

content/opportunities.md

@@ -0,0 +1,9 @@
++++
+title: Opportunities
++++
+
+Developer Grants
+Work on Urbit - get a job
+Contributors considered first
+Tlon, Tirrel, dcSpark
+The Combine

content/primer.md

@@ -0,0 +1,23 @@
++++
+title: Primer
++++
+
+Urbit development involves a fairly typical client/server/database stack. Urbit is both a server, database, and an entire operating system—this means exposes a filesystem, HTTP server, timer, and much more to the programmer (these different parts of the operating system are called vanes).
+
+Clients that interact with Urbit can be web browsers, mobile or desktop applications, command lines, or anything else that presents a user interface. At time of writing, most clients communicate with Urbit over HTTP by sending JSON back and forth, primarily via pub/sub APIs.
+
+Where Urbit differs from other client/server stacks is that all users run their own servers (urbits), and those servers talk directly to one another. Because those servers are also databases, all users store their own data, which they exchange with one another based on application-level logic.
+
+Urbit allows programmers to create what are called agents, which can be thought of as individual microservices—each one contains its own logic, defines its own API, can be started and stopped, can interact with the rest of the operating system and other agents, and is responsible for storing its own data. The lifecycle of agents is managed by the part of the operating system called gall.
+
+Since Urbit is actually an operating system, not just a server, when we talk about an Urbit “application” we could mean any of several things:
+
+A web or mobile interface that interacts with one or more agents to define something that looks a lot like an “app”;
+A single agent that runs in the background;
+A script that’s executed from Urbit’s own CLI (called the dojo)—these are called generators;
+
+Generators, agents and supporting code is packaged up into desks. These provide a mechanism for packaging up related code, and can be shared directly with other users over the network—this is how software distribution works on Urbit.
+
+All Urbit-side code is written in a purely functional and statically typed language called Hoon. Hoon looks kind of strange compared to most other programming languages, primarily because it’s based on runes rather than keywords. This strangeness is due to unfamiliarity rather than any form of essential complexity, in much the same way as Chinese appears more complex to an English-speaker than, say, Spanish.
+
+It’s possible to develop for Urbit without learning Hoon by learning its client-side HTTP interface; however, investing the time to learn Hoon will make you a far more capable Urbit developer, so we definitely recommend it. Ready to get started? Begin with our Urbit 101 course.

content/why.md

@@ -0,0 +1,15 @@
++++
+title: Why become an Urbit developer?
++++
+
+Urbit is a novel general-purpose computer that’s captivated thousands, and it’s no wonder why—truly novel computing architectures are few and far between, and they tend to be highly transformative. For recent examples, consider iOS and Ethereum. We think Urbit is at least as big of a deal.
+
+Most developers are drawn to Urbit because they’re fascinated by it—this author being no exception. The artful elegance of Nock, Hoon, and Arvo are reason enough for many, but are by no means the only reasons to bother learning Urbit.
+
+For one, Urbit is useful. There are real applications built on it that have properties you simply can’t find elsewhere. Its promise to developers is that distributed peer-to-peer applications, traditionally some of the hardest to build, can be built with ease and simple, understandable architectures. Urbit as a stack stands in stark contrast to the bloated tarpit of complexity that is modern networked software development. WIP
+
+Aside from the lofty philosophical ideals that are at arguable stages of progress, Urbit has a thriving, friendly, helpful community of developers that cooperate out of a shared desire to make programming better and more fun. You’ll find gray-haired industry veterans, new students, beginners to programming, IoT enthusiasts, and degens, …—a wide gamut of hackers. WIP
+
+Being in its early stages of development, Urbit is also an exciting space to develop within—pretty much everything is greenfield, leaving a new future to be invented. WIP
+
+[1] But we would, wouldn’t we?

pages/index.js

@@ -2,14 +2,68 @@ import Head from "next/head";
 
 export default function Home() {
   return (
-    <div className="flex flex-col items-center justify-center min-h-screen py-2">
+    <div className="">
       <Head>
         <title>Urbit Developers</title>
         <link rel="icon" href="/favicon.ico" />
       </Head>
 
-      <main className="flex flex-col items-center justify-center w-full flex-1 px-20 text-center">
-        <p>Hello world!</p>
+      <main className="">
+        <h1>
+          Urbit is a general-purpose platform for building decentralized,
+          peer-to-peer applications.
+        </h1>
+        <button>
+          <span className="type-ui">Learn More</span>
+        </button>
+        <h2>Learn</h2>
+        <span>Become an Urbit developer</span>
+
+        <p>
+          Urbit is an entirely new computer and novel programming environment.
+          Start with our series of self-guided courses.{" "}
+        </p>
+
+        <p>
+          You can get a high level overview with the primer, or jump into
+          learning with a series of self-led courses designed to teach you the
+          basics called Urbit 101. If you’re already familiar with the basics,
+          consult the series of standalone guides called Urbit 201.
+        </p>
+
+        <p>Stack overview | Urbit 101 | Urbit 201 </p>
+
+        <h2>Community</h2>
+        <span>Join the community </span>
+
+        <p>
+          The developer community is friendly, helpful, and organized from
+          within Urbit itself—but you don’t have to take our word for it! Join
+          our public groups on the network, or tune into a Developer Call to
+          join the community.{" "}
+        </p>
+
+        <p>Get involved | Developer Calls | Join the mailing list </p>
+
+        <p>
+          The mailing list is meant to be a separate, developer-only list for
+          those that want to stay up-to-date on developer-specific
+          announcements. These would be things like new documentation, upcoming
+          developer calls, infrastructure updates/breaking changes, etc.{" "}
+        </p>
+
+        <h2>Opportunities </h2>
+        <span>Apply your skills</span>
+
+        <p>
+          The Urbit ecosystem is growing rapidly, which presents many
+          opportunities to enterprising developers. Address space grants through
+          the Urbit Foundation are a great way to take your skills to the next
+          level. Companies like Tlon are regularly hiring developers, and The
+          Combine is funding startups that build on Urbit.{" "}
+        </p>
+
+        <p>Grants | Jobs | The Combine</p>
       </main>
     </div>
   );