This page is useful if you want to build an app using Aether’s technology.
Mim protocol, or more specifically, c0 subprotocol of Mim, is the underlying communication method of Aether.
It’s a stateless protocol that is based on HTTP GET and POST requests between peers. It has a small complement called TCPMim that works with raw TCP sockets to enable things like reverse opens.
You can find Mim and c0 documentation here.
Compile instructions for Aether P2P
This documentation is a work in progress. Please check back for updates.
This documentation is created to help you get started on compiling Aether. It is not meant to be a step-by-step guide, more as a series of notes on best practices.
You need the most recent version of Go (1.13 at the time of writing), Node 11, and the usual C / clang dependencies. Please make sure before you go in that these dependencies are installed, and functioning correctly. You also need to have the protocol buffer toolchain to compile them if you want to make and wire-level changes to communications between the client, frontend and the backend.
These instructions are written for Mac OS. However, given the similarity, Linux, and to a lesser degree, other UNIXes should be relatively easy to get to work.
If you’re on Windows, it’s almost certain that none of this will work, even with WSL or cygwin.
If you’re on Mac OS, you also need a current version of Xcode that is ready to go. This is required because Xcode is how you get Clang (a C compiler) in Mac OS. We otherwise have no business with it.
(If you want to package the app in Linux, you’ll need to write a few lines of code to fix paths, but other than that, it should work.)
Aether is a large program that is built using a compilation pipeline that covers multiple languages, some of which are low-level.
If you want to hack on the graph compiler, you should know Go and gRPC. Aether Frontend is our graph compiler written in Go. This is the layer that compiles the signals received from the network into a user-navigable view data stored in a key-value database.
If you want to hack on the backend, you should know Go, gRPC and some wire-level networking. Aether backend handles the communication with other Aether peers in the network.
Getting it to run from your local compile
Aether can run un-compiled directly at runtime. This is useful for debugging and it is a first step in making sure your environment.
Install latest Go, Node 11, NPM and confirm that it works
Pull the repository from Github (https://github.com/nehbit/aether)
go run main.go. it should print an identifier and terminate itself. If it doesn’t, and you encounter with some errors. Fix the errors before moving any further.
aether-core/aether/client, and do
npm ci. This will trigger a rather process that will install the Node dependencies and their native dependencies.
npm run wpwatch. This will compile the JS dependencies. Fix if there are any errors.
npm run rebuild. This will build your C / native dependencies based on your platform, in this case, Electron. This will take some time. On my machine, it’s about 5-10 minutes, but it can go up to 30-40 depending on your hardware.
When done, try to start the app uncompiled using
npm start. Make sure that if you’re running Aether in your computer, you have it shut down, otherwise Electron’s single instance lock will trigger and terminate your uncompiled run without errors.
If you end up seeing nothing, you might want to open the js console with
Shift + Cmd (Super) + Iand take a look at the errors, if any.
At this point, you should have the app running, using your local Aether user profile, if any present.
Packaging the app
aether-core/aether, and do
make(For Mac OS, Linux and Windows compile), or
make linuxas needed. The latter two assumes a Mac environment, so if you want to compile natively on Linux, you should take a look at the Mac make process the makefile, and change the paths to work for Linux.
On Windows and Mac OS, you need a developer certificate (purchasable from Apple and Microsoft’s third-party resellers, respectively) to allow the packaged app to run on any computer without developer flags. (This is not specific to Aether, this applies to all apps on those platforms.)