Cone is built to go fast, in two senses.

Fast programs. Programs that do their work with as little time and memory as the work allows: compiled to native code, with each value's memory managed the way that value needs, and every core of the machine put to use.

Fast programmers. Programs that stay quick to change, above all over the years a complex system is maintained. That is where Cone aims to save you the most time: by letting the code say what you mean, and by having the compiler catch what a change breaks, while the change is still in front of you.

Much of Cone's design serves both at once. Three features show it best. Each has a short story of its own.

Choose how memory is managed, value by value

A game's terrain has one owner. Its rock mesh is shared by hundreds of models. Its creatures come and go, and each frame's debris is gone a frame later. In Cone each of them can be managed its own way, in one program, and a single function can draw them all without paying for any of it. One set of borrowing rules keeps every strategy safe, and changing your mind later can take one line. Read the story.

Shared, mutable data, without the usual fight

Two views hold one document, and either may change it. Nothing is wrapped, flagged or locked. Yet the compiler still catches the one change that would pull memory out from under a borrow, and the one move that would let the document slip onto another thread. Read the story.

Actors and parallel each: concurrency free of data races

A bakery's two tills sell from one stock room and never sell the same loaf twice, with no lock in sight. A year of orders is discounted on every core by adding one word to a loop. Both are checked for data races when you compile. Read the story.

Still to come

These parts of the section are being written.

Fast programs

Fast programmers