1 What is Goblins?

      1.1 What works so far?

      1.2 What’s on its way?

    2 A tutorial

      2.1 Getting going

      2.2 Vats, actors, spawning, and immediate calls

      2.3 Message passing, promises, and multiple vats

        2.3.1 The basics

        2.3.2 Making and resolving our own promises

        2.3.3 Finally we have #:finally

        2.3.4 The on-fulfilled handler of "on" is optional

        2.3.5 "on" with non-promise values

        2.3.6 "on" can return promises too

        2.3.7 Promise pipelining

        2.3.8 Broken promise contagion

      2.4 Going low-level: actormaps

        2.4.1 Spawning, peeking, poking, turning

        2.4.2 Time travel: snapshotting and restoring

      2.5 Advanced object patterns

        2.5.1 Extending our methods

        2.5.2 Mixins

        2.5.3 Behavior pivoting as a kind of state machine

      2.6 How this relates to "object capability security"

      2.7 Sealers/unsealers and rights amplification

      2.8 Networked object interactions

      2.9 A peek into Goblins’ machinery

        2.9.1 Actors really are what they say they are

        2.9.2 So how does message passing work

        2.9.3 How can two actormaps communicate? (How do vats do it?)

    3 Goblins API

      3.1 Actors

        3.1.1 What is an "actor" in Goblins?

        3.1.2 Constructors and bcom

      3.2 Core procedures

      3.3 References

        3.3.1 Live vs Sturdy references

        3.3.2 Near vs far references

        3.3.3 Local vs remote references

      3.4 Actormaps

        3.4.1 Actormap methods

        3.4.2 whactormap

        3.4.3 transactormap

        3.4.4 Snapshotting and restoring actormaps

        3.4.5 Extra actormap procedures

        3.4.6 Vat connectors

      3.5 Vats

      3.6 Promises

      3.7 Machines

    4 Actor lib: a collection of utilities

      4.1 Cells

      4.2 Methods

      4.3 Facets

      4.4 Revokeable caretakers

      4.5 Cartoon swearing (select-$/<-)

      4.6 Etc etc...