diff --git a/.gitignore b/.gitignore
index 8edf18f..c52438c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,3 +3,4 @@
 coverage.out
 *.code-workspace
 *target/debug*
+*.vscode*
diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 0000000..fd2ab58
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,3 @@
+{
+  "python.pythonPath": "/usr/bin/python3"
+}
\ No newline at end of file
diff --git a/go/deltav/common/counters/counters.go b/go/deltav/common/counters/counters.go
new file mode 100644
index 0000000..a040ec2
--- /dev/null
+++ b/go/deltav/common/counters/counters.go
@@ -0,0 +1,21 @@
+package counters
+
+type Counter struct {
+	counters map[string]uint64
+}
+
+func New() *Counter {
+	return &Counter{counters: make(map[string]uint64)}
+}
+
+func (c *Counter) Inc(key string) {
+	c.counters[key]++
+}
+
+func (c *Counter) Get(key string) uint64 {
+	count, ok := c.counters[key]
+	if !ok {
+		return 0
+	}
+	return count
+}
diff --git a/go/deltav/common/objects.go b/go/deltav/common/objects.go
new file mode 100644
index 0000000..7affce5
--- /dev/null
+++ b/go/deltav/common/objects.go
@@ -0,0 +1,5 @@
+package common
+
+type Object interface {
+	GetID() string
+}
diff --git a/go/deltav/deltav.go b/go/deltav/deltav.go
new file mode 100644
index 0000000..7aec7c5
--- /dev/null
+++ b/go/deltav/deltav.go
@@ -0,0 +1 @@
+package deltav
diff --git a/go/deltav/detectable/detectable.go b/go/deltav/detectable/detectable.go
new file mode 100644
index 0000000..58839a6
--- /dev/null
+++ b/go/deltav/detectable/detectable.go
@@ -0,0 +1,194 @@
+package detectable
+
+import (
+	"fmt"
+	"math"
+
+	"github.com/golang001/deltav/common/counters"
+	protos "github.com/golang001/deltav/model/gomodel"
+)
+
+// TraceDetectable is a stuct point-in-time history of an object.
+type TraceDetectable struct {
+	Pos        protos.Position
+	Properties map[PropertyType]*Property
+	ID         string
+}
+
+func NewTraceDetectable(x float64, y float64, z float64, t int64, id string) *TraceDetectable {
+	return &TraceDetectable{
+		Pos:        protos.Position{Position: &protos.Vector3{X: x, Y: y, Z: z}, T: t},
+		ID:         id,
+		Properties: make(map[PropertyType]*Property)}
+}
+
+func (td *TraceDetectable) AddProperty(p Property) *TraceDetectable {
+	td.Properties[p.PropertyType] = &p
+	return td
+}
+
+func (td *TraceDetectable) GetPosition() protos.Position {
+	return td.Pos
+}
+
+func (td *TraceDetectable) GetProperty(propType PropertyType) (*Property, error) {
+	prop, ok := td.Properties[propType]
+	if !ok {
+		return nil, fmt.Errorf("property not found")
+	}
+	return prop, nil
+}
+
+func (td *TraceDetectable) GetID() string {
+	return td.ID
+}
+
+func (td *TraceDetectable) Compare(req DetectRequest) bool {
+	if req.Pos.T < td.Pos.T {
+		return false
+	}
+	deltaPos := td.Pos.Subtract(&req.Pos)
+	sqMag := deltaPos.Position.MagnitudeSquared()
+	lightTravelTimeSquared := sqMag * InverseCSquared
+	deltaTimeSquared := deltaPos.T * deltaPos.T
+	if math.Abs(lightTravelTimeSquared-float64(deltaTimeSquared)) >= 1 {
+		return false
+	}
+
+	if req.Range*req.Range < sqMag {
+		return false
+	}
+
+	if len(req.Filter) == 0 {
+		return true
+	}
+
+	for _, pt := range req.Filter {
+		for key := range td.Properties {
+			if key == pt {
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
+type DetectableHistory struct {
+	hist             map[int64]Detectable
+	maxMagnitudeSqrd float64
+}
+
+func NewDetectableHistory() *DetectableHistory {
+	return &DetectableHistory{hist: make(map[int64]Detectable), maxMagnitudeSqrd: 0}
+}
+
+func (hist *DetectableHistory) Insert(d Detectable) {
+	hist.hist[d.GetPosition().T] = d
+	pos := d.GetPosition()
+	var mag float64 = pos.Position.MagnitudeSquared()
+	if hist.maxMagnitudeSqrd < mag {
+		hist.maxMagnitudeSqrd = mag
+	}
+}
+
+func (hist *DetectableHistory) Prune(minTime int64) {
+	for k := range hist.hist {
+		if k < minTime {
+			delete(hist.hist, k)
+		}
+	}
+}
+
+type DetectableDatabase struct {
+	//Todo, make threadsafe
+	db    map[string](*DetectableHistory)
+	count *counters.Counter
+}
+
+func (db *DetectableDatabase) Size() int64 {
+	total := int64(0)
+	for _, hist := range db.db {
+		total += int64(len(hist.hist))
+	}
+	return total
+}
+
+func NewDetectableDatabase() *DetectableDatabase {
+	return &DetectableDatabase{
+		db:    make(map[string]*DetectableHistory),
+		count: counters.New(),
+	}
+}
+
+func (db *DetectableDatabase) Register(obj Detectable) {
+	hist, ok := db.db[obj.GetID()]
+	if !ok {
+		hist = NewDetectableHistory()
+	}
+
+	hist.Insert(obj)
+	db.db[obj.GetID()] = hist
+}
+
+func detectThreaded(req DetectRequest, hist *DetectableHistory, detected chan *Detectable) {
+	for i := req.Pos.T; i >= 0; i-- {
+		d, ok := hist.hist[i]
+		if !ok {
+			continue
+		}
+		if d.Compare(req) {
+			detected <- &d
+			break
+		}
+	}
+	detected <- nil
+}
+
+func (db *DetectableDatabase) Prune(currTime int64) {
+	// Finds the max distance from the origin from a trackable object
+	// and how long light takes to travel to it. Then, it doubles that
+	// time and removes all elements further than that away from the
+	// origin.
+	maxMagSqrd := float64(0)
+	for _, hist := range db.db {
+		if hist.maxMagnitudeSqrd > maxMagSqrd {
+			maxMagSqrd = hist.maxMagnitudeSqrd
+		}
+	}
+
+	fmt.Printf("maxMag %f", maxMagSqrd)
+	minTime := currTime - int64(math.Sqrt(maxMagSqrd)*2*math.Sqrt(InverseCSquared))
+	fmt.Printf("pruning before time %d", minTime)
+	done := make([](chan bool), len(db.db))
+	i := 0
+	for _, hist := range db.db {
+		done[i] = make(chan bool)
+		go func(hist *DetectableHistory, minTime int64, d chan bool) {
+			hist.Prune(minTime)
+			d <- true
+		}(hist, minTime, done[i])
+		i++
+	}
+	for _, d := range done {
+		<-d
+	}
+}
+
+func (db *DetectableDatabase) Detect(req DetectRequest) DetectResponse {
+	resp := DetectResponse{detected: []Detectable{}}
+	detectedChannels := make([](chan *Detectable), len(db.db))
+	counter := 0
+	for key, hist := range db.db {
+		db.count.Inc(fmt.Sprintf("detecting.%s", key))
+		detectedChannels[counter] = make(chan *Detectable)
+		go detectThreaded(req, hist, detectedChannels[counter])
+		counter++
+	}
+	for _, ch := range detectedChannels {
+		if det := <-ch; det != nil {
+			resp.detected = append(resp.detected, *(det))
+		}
+	}
+	return resp
+}
diff --git a/go/deltav/detectable/detectable_test.go b/go/deltav/detectable/detectable_test.go
new file mode 100644
index 0000000..771782b
--- /dev/null
+++ b/go/deltav/detectable/detectable_test.go
@@ -0,0 +1,199 @@
+package detectable
+
+import (
+	"fmt"
+	"math/rand"
+	"testing"
+	"time"
+
+	protos "github.com/golang001/deltav/model/gomodel"
+	"github.com/stretchr/testify/assert"
+)
+
+func getLargeRandomPS(gameLengthMinutes int64, trackableEntities int) *DetectableDatabase {
+	objs := []*TraceDetectable{}
+	for i := 0; i < trackableEntities; i++ {
+		objs = append(objs,
+			NewTraceDetectable(0, 0, 0, 0, fmt.Sprintf("%d", i)))
+	}
+
+	db := NewDetectableDatabase()
+
+	for i := int64(0); i < gameLengthMinutes*60; i++ {
+		for _, obj := range objs {
+			obj.Pos.Position.X += (rand.Float64())
+			obj.Pos.Position.Y += (rand.Float64())
+			obj.Pos.Position.Z += (rand.Float64())
+			obj.Pos.T = i
+			db.Register(obj)
+		}
+	}
+	return db
+}
+
+func TestDetectableLookback(t *testing.T) {
+	InverseCSquared = 1 //Overwrite to make math easier.
+	var pos PositionSystem = NewDetectableDatabase()
+	pos.Register(NewTraceDetectable(0, 0, 0, 0, "A"))
+	pos.Register(NewTraceDetectable(0, 0, 0, 1, "B"))
+	pos.Register(NewTraceDetectable(0, 0, 0, 2, "C"))
+	pos.Register(NewTraceDetectable(0, 0, 0, 3, "D"))
+	pos.Register(NewTraceDetectable(0, 0, 0, 4, "E"))
+
+	req := DetectRequest{Pos: protos.Position{Position: &protos.Vector3{X: 1, Y: 0, Z: 0}, T: 3},
+		Range: 10, Filter: []PropertyType{}}
+
+	resp := pos.Detect(req)
+
+	assert.Equal(t, 1, len(resp.detected))
+	assert.Equal(t, "C", resp.detected[0].GetID())
+}
+
+func TestDetectableRange(t *testing.T) {
+	InverseCSquared = 1 //Overwrite to make math easier.
+	var pos PositionSystem = NewDetectableDatabase()
+	prop := Property{Intensity: 10, PropertyType: GammaRadiation}
+	pos.Register(NewTraceDetectable(10, 0, 0, 0, "A").AddProperty(prop))
+	pos.Register(NewTraceDetectable(100, 0, 0, 0, "B").AddProperty(prop))
+	pos.Register(NewTraceDetectable(10, 0, 0, 0, "C")) //Is not gamma.
+
+	// A is found but c is not because we're filtering for gamma.
+	req := DetectRequest{Pos: protos.Position{Position: &protos.Vector3{X: 0, Y: 0, Z: 0}, T: 10},
+		Range: 10, Filter: []PropertyType{GammaRadiation}}
+	resp := pos.Detect(req)
+	assert.Equal(t, 1, len(resp.detected))
+	assert.Equal(t, "A", resp.detected[0].GetID())
+
+	//Won't see B because its too far away
+	req = DetectRequest{Pos: protos.Position{Position: &protos.Vector3{X: 0, Y: 0, Z: 0}, T: 100},
+		Range: 10, Filter: []PropertyType{GammaRadiation}}
+
+	resp = pos.Detect(req)
+	assert.Equal(t, 0, len(resp.detected))
+
+	//Will see B with higher range.
+	req = DetectRequest{Pos: protos.Position{Position: &protos.Vector3{X: 0, Y: 0, Z: 0}, T: 100},
+		Range: 1000, Filter: []PropertyType{GammaRadiation}}
+
+	resp = pos.Detect(req)
+
+	assert.Equal(t, 1, len(resp.detected))
+	assert.Equal(t, "B", resp.detected[0].GetID())
+}
+
+func TestDetectableMultiItem(t *testing.T) {
+	InverseCSquared = 1 //Overwrite to make math easier.
+	var pos PositionSystem = NewDetectableDatabase()
+
+	for i := int64(0); i < 100; i++ {
+		r := rand.Float64() * 1000
+		pos.Register(NewTraceDetectable(r, r, r, i, "A"))
+		pos.Register(NewTraceDetectable(r, r, r, i, "B"))
+		pos.Register(NewTraceDetectable(r, r, r, i, "C"))
+		pos.Register(NewTraceDetectable(r, r, r, i, "D"))
+		pos.Register(NewTraceDetectable(r, r, r, i, "E"))
+		pos.Register(NewTraceDetectable(r, r, r, i, "F"))
+	}
+
+	pos.Register(NewTraceDetectable(2, 0, 0, 10, "A"))
+	pos.Register(NewTraceDetectable(0, 2, 0, 10, "B"))
+	pos.Register(NewTraceDetectable(0, 0, 2, 10, "C"))
+	pos.Register(NewTraceDetectable(-2, 0, 0, 10, "D"))
+	pos.Register(NewTraceDetectable(0, -2, 0, 10, "E"))
+	pos.Register(NewTraceDetectable(0, 0, -2, 10, "F"))
+
+	assert.Equal(t, 6, len(pos.(*DetectableDatabase).db))
+	assert.Equal(t, 100, len(pos.(*DetectableDatabase).db["A"].hist))
+	assert.Equal(t, 100, len(pos.(*DetectableDatabase).db["F"].hist))
+
+	req := DetectRequest{Pos: protos.Position{Position: &protos.Vector3{X: 0, Y: 0, Z: 0}, T: 12},
+		Range: 10, Filter: []PropertyType{}}
+
+	resp := pos.Detect(req)
+
+	assert.Equal(t, 6, len(resp.detected))
+	countMap := make(map[string]int)
+	for _, val := range resp.detected {
+		// Each key should be unique A-F
+		_, ok := countMap[val.GetID()]
+		assert.False(t, ok)
+		countMap[val.GetID()]++
+	}
+}
+
+func TestGetLargeRandomPs(t *testing.T) {
+	pos := getLargeRandomPS(60, 1000)
+	assert.Equal(t, 1000, len(pos.db))
+	for _, hist := range pos.db {
+		assert.Equal(t, 60*60, len(hist.hist))
+	}
+}
+
+func TestDetectPerformance(t *testing.T) {
+	InverseCSquared = 0.001
+	pos := getLargeRandomPS(60, 1000)
+
+	beforeTime := time.Now()
+	req := DetectRequest{Pos: protos.Position{Position: &protos.Vector3{X: 0, Y: 0, Z: 0}, T: 60},
+		Range: 10, Filter: []PropertyType{}}
+
+	pos.Detect(req)
+	afterTime := time.Now()
+
+	assert.WithinDuration(t, beforeTime, afterTime, 10*time.Millisecond)
+}
+
+func TestPrune(t *testing.T) {
+	InverseCSquared = 0.01
+	pos := NewDetectableDatabase()
+
+	pos.Register(NewTraceDetectable(10, 0, 0, 1, "A"))
+	pos.Register(NewTraceDetectable(20, 0, 0, 2, "A"))
+	pos.Register(NewTraceDetectable(30, 0, 0, 3, "A"))
+	pos.Register(NewTraceDetectable(40, 0, 0, 4, "A"))
+	pos.Register(NewTraceDetectable(50, 0, 0, 5, "A"))
+	pos.Register(NewTraceDetectable(60, 0, 0, 6, "A"))
+	pos.Register(NewTraceDetectable(70, 0, 0, 7, "A"))
+	pos.Register(NewTraceDetectable(80, 0, 0, 8, "A"))
+	pos.Register(NewTraceDetectable(90, 0, 0, 9, "A"))
+	// 10 seconds to origin, 20 seconds retained. Its the furtherst object form the
+	// origin so we double the time it takes light to reach the origin and set that as the retention limit.
+	pos.Register(NewTraceDetectable(100, 0, 0, 10, "A"))
+
+	pos.Prune(10)
+	assert.Equal(t, int64(10), pos.Size()) // Nothing should get pruned.
+
+	for i := int64(11); i <= 30; i++ {
+		pos.Register(NewTraceDetectable(100, 0, 0, i, "A"))
+
+	}
+	assert.Equal(t, int64(30), pos.Size())
+	pos.Prune(20)
+	assert.Equal(t, int64(30), pos.Size())
+	pos.Prune(30)
+	assert.Equal(t, int64(21), pos.Size()) //Inly the last 20 seconds are retained.
+}
+
+// func TestPrunePerfromance(t *testing.T) {
+// 	InverseCSquared = DefaultInverseC()
+// 	fmt.Printf("%f\n", InverseCSquared)
+// 	pos := getLargeRandomPS(60, 1000)
+
+// 	assert.Equal(t, int64(60*60*1000), pos.Size())
+
+// 	// Pruning a big db is 100 ms
+// 	beforeTime := time.Now()
+// 	pos.Prune(60 * 60)
+// 	afterTime := time.Now()
+
+// 	assert.WithinDuration(t, beforeTime, afterTime, 100*time.Millisecond)
+// 	assert.Equal(t, int64(6*1000), pos.Size())
+
+// 	//Pruining a "pruned" db is fast.
+// 	beforeTime = time.Now()
+// 	pos.Prune(60 * 60)
+// 	afterTime = time.Now()
+
+// 	assert.WithinDuration(t, beforeTime, afterTime, 20*time.Millisecond)
+// 	assert.Equal(t, int64(6*1000), pos.Size())
+// }
diff --git a/go/deltav/detectable/structs.go b/go/deltav/detectable/structs.go
new file mode 100644
index 0000000..0acefe9
--- /dev/null
+++ b/go/deltav/detectable/structs.go
@@ -0,0 +1,49 @@
+package detectable
+
+import (
+	"math"
+
+	protos "github.com/golang001/deltav/model/gomodel"
+)
+
+const C = float64(1000) // Units / second
+var InverseCSquared = math.Pow(1/C, 2)
+
+func DefaultInverseC() float64 {
+	return math.Pow(float64(1)/C, 2)
+}
+
+type Property struct {
+	Intensity    float32
+	PropertyType PropertyType
+}
+
+type PropertyType int
+
+var (
+	GammaRadiation PropertyType = 1
+	EMRadiation    PropertyType = 2
+	RFRadiation    PropertyType = 2
+)
+
+type DetectRequest struct {
+	Pos    protos.Position
+	Range  float64
+	Filter []PropertyType
+}
+
+type DetectResponse struct {
+	detected []Detectable
+}
+
+type PositionSystem interface {
+	Detect(DetectRequest) DetectResponse
+	Register(Detectable)
+}
+
+type Detectable interface {
+	GetPosition() protos.Position
+	GetProperty(PropertyType) (*Property, error)
+	GetID() string
+	Compare(DetectRequest) bool
+}
diff --git a/go/deltav/mastercontrol/main/main.go b/go/deltav/mastercontrol/main/main.go
new file mode 100644
index 0000000..a0e8e61
--- /dev/null
+++ b/go/deltav/mastercontrol/main/main.go
@@ -0,0 +1,53 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"net"
+	"time"
+
+	master "github.com/golang001/deltav/mastercontrol"
+	protos "github.com/golang001/deltav/model/gomodel"
+	"golang.org/x/net/context"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/reflection"
+)
+
+const (
+	port = ":50051"
+)
+
+type server struct {
+	mc *master.MasterControl
+}
+
+func (s *server) Register(ctx context.Context, req *protos.RegisterRequest) (*protos.RegisterResponse, error) {
+	fmt.Printf("Register: %s - %s\n", "req.ID", time.Now().String())
+	return &protos.RegisterResponse{Effect: "success"}, nil
+}
+
+func (s *server) Detect(ctx context.Context, req *protos.DetectRequest) (*protos.DetectResponse, error) {
+	return &protos.DetectResponse{}, nil
+}
+
+func (s *server) Get(ctx context.Context, req *protos.GetRequest) (*protos.GetResponse, error) {
+	return &protos.GetResponse{}, nil
+}
+
+func (s *server) Initialize(ctx context.Context, req *protos.InitializeRequest) (*protos.InitializeResponse, error) {
+	return &protos.InitializeResponse{}, nil
+}
+
+func main() {
+	lis, err := net.Listen("tcp", port)
+	if err != nil {
+		log.Fatalf("failed to listen: %v", err)
+	}
+	serve := grpc.NewServer()
+	protos.RegisterWorldModelServer(serve, &server{})
+	// Register reflection service on gRPC server.
+	reflection.Register(serve)
+	if err := serve.Serve(lis); err != nil {
+		log.Fatalf("failed to serve: %v", err)
+	}
+}
diff --git a/go/deltav/mastercontrol/mastercontrol.go b/go/deltav/mastercontrol/mastercontrol.go
new file mode 100644
index 0000000..06256d2
--- /dev/null
+++ b/go/deltav/mastercontrol/mastercontrol.go
@@ -0,0 +1,35 @@
+package mastercontrol
+
+import (
+	"fmt"
+
+	"github.com/golang001/deltav/detectable"
+	protos "github.com/golang001/deltav/model/gomodel"
+	"github.com/satori/go.uuid"
+)
+
+type MasterControl struct {
+	database detectable.DetectableDatabase
+
+	//Map of ids to their objects.'s.
+	objects map[string]interface{}
+}
+
+func (mc *MasterControl) insert(key string, obj interface{}) error {
+	_, ok := mc.objects[key]
+	if ok {
+		return fmt.Errorf("key in use")
+	}
+	mc.objects[key] = obj
+	return nil
+}
+
+func (mc *MasterControl) Initialize(req *protos.InitializeRequest) error {
+	id := uuid.NewV4()
+	err := mc.insert(id.String(), req.Vessel)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
diff --git a/go/deltav/model/driver.proto b/go/deltav/model/driver.proto
new file mode 100644
index 0000000..68bd6fa
--- /dev/null
+++ b/go/deltav/model/driver.proto
@@ -0,0 +1,24 @@
+syntax = "proto3";
+
+package deltav.model;
+
+import "position.proto";
+/*
+A driver is the system that controls thrust of the whole ship. The ship requests a change in kinetic
+energy and the drive attempts to satisfy the request.
+
+A Driver will typically contain a reactor, fuel tanks, radiator, and heat sink. 
+
+*/
+message DriveRequest {
+    Vector3 orientation = 1;
+    int64 kinetic_energy = 2; 
+}
+
+message DriveResponse {
+    int64 kinetic_energy_delivered = 2;
+}
+
+service Driver {
+    rpc Drive(DriveRequest) returns (DriveResponse) {}
+}  
\ No newline at end of file
diff --git a/go/deltav/model/gomock/gomocks.go b/go/deltav/model/gomock/gomocks.go
new file mode 100644
index 0000000..7cfb1ba
--- /dev/null
+++ b/go/deltav/model/gomock/gomocks.go
@@ -0,0 +1,131 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/golang001/deltav/model/gomodel (interfaces: StorageTankClient,ReactorClient)
+
+// Package mock_gomodel is a generated GoMock package.
+package mock_gomodel
+
+import (
+	context "context"
+	gomock "github.com/golang/mock/gomock"
+	gomodel "github.com/golang001/deltav/model/gomodel"
+	grpc "google.golang.org/grpc"
+	reflect "reflect"
+)
+
+// MockStorageTankClient is a mock of StorageTankClient interface
+type MockStorageTankClient struct {
+	ctrl     *gomock.Controller
+	recorder *MockStorageTankClientMockRecorder
+}
+
+// MockStorageTankClientMockRecorder is the mock recorder for MockStorageTankClient
+type MockStorageTankClientMockRecorder struct {
+	mock *MockStorageTankClient
+}
+
+// NewMockStorageTankClient creates a new mock instance
+func NewMockStorageTankClient(ctrl *gomock.Controller) *MockStorageTankClient {
+	mock := &MockStorageTankClient{ctrl: ctrl}
+	mock.recorder = &MockStorageTankClientMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockStorageTankClient) EXPECT() *MockStorageTankClientMockRecorder {
+	return m.recorder
+}
+
+// AddStorage mocks base method
+func (m *MockStorageTankClient) AddStorage(arg0 context.Context, arg1 *gomodel.AddStorageRequest, arg2 ...grpc.CallOption) (*gomodel.AddStorageResponse, error) {
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AddStorage", varargs...)
+	ret0, _ := ret[0].(*gomodel.AddStorageResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AddStorage indicates an expected call of AddStorage
+func (mr *MockStorageTankClientMockRecorder) AddStorage(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddStorage", reflect.TypeOf((*MockStorageTankClient)(nil).AddStorage), varargs...)
+}
+
+// Status mocks base method
+func (m *MockStorageTankClient) Status(arg0 context.Context, arg1 *gomodel.StorageStatusRequest, arg2 ...grpc.CallOption) (*gomodel.StorageStatusResponse, error) {
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "Status", varargs...)
+	ret0, _ := ret[0].(*gomodel.StorageStatusResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Status indicates an expected call of Status
+func (mr *MockStorageTankClientMockRecorder) Status(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Status", reflect.TypeOf((*MockStorageTankClient)(nil).Status), varargs...)
+}
+
+// WithdrawStorage mocks base method
+func (m *MockStorageTankClient) WithdrawStorage(arg0 context.Context, arg1 *gomodel.WithdrawStorageRequest, arg2 ...grpc.CallOption) (*gomodel.WithdrawStorageResponse, error) {
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "WithdrawStorage", varargs...)
+	ret0, _ := ret[0].(*gomodel.WithdrawStorageResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// WithdrawStorage indicates an expected call of WithdrawStorage
+func (mr *MockStorageTankClientMockRecorder) WithdrawStorage(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithdrawStorage", reflect.TypeOf((*MockStorageTankClient)(nil).WithdrawStorage), varargs...)
+}
+
+// MockReactorClient is a mock of ReactorClient interface
+type MockReactorClient struct {
+	ctrl     *gomock.Controller
+	recorder *MockReactorClientMockRecorder
+}
+
+// MockReactorClientMockRecorder is the mock recorder for MockReactorClient
+type MockReactorClientMockRecorder struct {
+	mock *MockReactorClient
+}
+
+// NewMockReactorClient creates a new mock instance
+func NewMockReactorClient(ctrl *gomock.Controller) *MockReactorClient {
+	mock := &MockReactorClient{ctrl: ctrl}
+	mock.recorder = &MockReactorClientMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockReactorClient) EXPECT() *MockReactorClientMockRecorder {
+	return m.recorder
+}
+
+// React mocks base method
+func (m *MockReactorClient) React(arg0 context.Context, arg1 *gomodel.ReactRequest, arg2 ...grpc.CallOption) (*gomodel.ReactResponse, error) {
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "React", varargs...)
+	ret0, _ := ret[0].(*gomodel.ReactResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// React indicates an expected call of React
+func (mr *MockReactorClientMockRecorder) React(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "React", reflect.TypeOf((*MockReactorClient)(nil).React), varargs...)
+}
diff --git a/go/deltav/model/gomodel/driver.pb.go b/go/deltav/model/gomodel/driver.pb.go
new file mode 100644
index 0000000..f55b6ae
--- /dev/null
+++ b/go/deltav/model/gomodel/driver.pb.go
@@ -0,0 +1,212 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: driver.proto
+
+package deltav_model
+
+import (
+	fmt "fmt"
+	proto "github.com/golang/protobuf/proto"
+	context "golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
+	math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+//
+//A driver is the system that controls thrust of the whole ship. The ship requests a change in kinetic
+//energy and the drive attempts to satisfy the request.
+//
+//A Driver will typically contain a reactor, fuel tanks, radiator, and heat sink.
+//
+type DriveRequest struct {
+	Orientation          *Vector3 `protobuf:"bytes,1,opt,name=orientation,proto3" json:"orientation,omitempty"`
+	KineticEnergy        int64    `protobuf:"varint,2,opt,name=kinetic_energy,json=kineticEnergy,proto3" json:"kinetic_energy,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *DriveRequest) Reset()         { *m = DriveRequest{} }
+func (m *DriveRequest) String() string { return proto.CompactTextString(m) }
+func (*DriveRequest) ProtoMessage()    {}
+func (*DriveRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_521003751d596b5e, []int{0}
+}
+
+func (m *DriveRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_DriveRequest.Unmarshal(m, b)
+}
+func (m *DriveRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_DriveRequest.Marshal(b, m, deterministic)
+}
+func (m *DriveRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DriveRequest.Merge(m, src)
+}
+func (m *DriveRequest) XXX_Size() int {
+	return xxx_messageInfo_DriveRequest.Size(m)
+}
+func (m *DriveRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_DriveRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DriveRequest proto.InternalMessageInfo
+
+func (m *DriveRequest) GetOrientation() *Vector3 {
+	if m != nil {
+		return m.Orientation
+	}
+	return nil
+}
+
+func (m *DriveRequest) GetKineticEnergy() int64 {
+	if m != nil {
+		return m.KineticEnergy
+	}
+	return 0
+}
+
+type DriveResponse struct {
+	KineticEnergyDelivered int64    `protobuf:"varint,2,opt,name=kinetic_energy_delivered,json=kineticEnergyDelivered,proto3" json:"kinetic_energy_delivered,omitempty"`
+	XXX_NoUnkeyedLiteral   struct{} `json:"-"`
+	XXX_unrecognized       []byte   `json:"-"`
+	XXX_sizecache          int32    `json:"-"`
+}
+
+func (m *DriveResponse) Reset()         { *m = DriveResponse{} }
+func (m *DriveResponse) String() string { return proto.CompactTextString(m) }
+func (*DriveResponse) ProtoMessage()    {}
+func (*DriveResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_521003751d596b5e, []int{1}
+}
+
+func (m *DriveResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_DriveResponse.Unmarshal(m, b)
+}
+func (m *DriveResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_DriveResponse.Marshal(b, m, deterministic)
+}
+func (m *DriveResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DriveResponse.Merge(m, src)
+}
+func (m *DriveResponse) XXX_Size() int {
+	return xxx_messageInfo_DriveResponse.Size(m)
+}
+func (m *DriveResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_DriveResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DriveResponse proto.InternalMessageInfo
+
+func (m *DriveResponse) GetKineticEnergyDelivered() int64 {
+	if m != nil {
+		return m.KineticEnergyDelivered
+	}
+	return 0
+}
+
+func init() {
+	proto.RegisterType((*DriveRequest)(nil), "deltav.model.DriveRequest")
+	proto.RegisterType((*DriveResponse)(nil), "deltav.model.DriveResponse")
+}
+
+func init() { proto.RegisterFile("driver.proto", fileDescriptor_521003751d596b5e) }
+
+var fileDescriptor_521003751d596b5e = []byte{
+	// 212 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x49, 0x29, 0xca, 0x2c,
+	0x4b, 0x2d, 0xd2, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x49, 0x49, 0xcd, 0x29, 0x49, 0x2c,
+	0xd3, 0xcb, 0xcd, 0x4f, 0x49, 0xcd, 0x91, 0xe2, 0x2b, 0xc8, 0x2f, 0xce, 0x2c, 0xc9, 0xcc, 0xcf,
+	0x83, 0xc8, 0x2a, 0xe5, 0x71, 0xf1, 0xb8, 0x80, 0x54, 0x07, 0xa5, 0x16, 0x96, 0xa6, 0x16, 0x97,
+	0x08, 0x99, 0x73, 0x71, 0xe7, 0x17, 0x65, 0xa6, 0xe6, 0x95, 0x24, 0x82, 0x14, 0x49, 0x30, 0x2a,
+	0x30, 0x6a, 0x70, 0x1b, 0x89, 0xea, 0x21, 0x9b, 0xa1, 0x17, 0x96, 0x9a, 0x5c, 0x92, 0x5f, 0x64,
+	0x1c, 0x84, 0xac, 0x52, 0x48, 0x95, 0x8b, 0x2f, 0x3b, 0x33, 0x2f, 0xb5, 0x24, 0x33, 0x39, 0x3e,
+	0x35, 0x2f, 0xb5, 0x28, 0xbd, 0x52, 0x82, 0x49, 0x81, 0x51, 0x83, 0x39, 0x88, 0x17, 0x2a, 0xea,
+	0x0a, 0x16, 0x54, 0xf2, 0xe4, 0xe2, 0x85, 0xda, 0x57, 0x5c, 0x90, 0x9f, 0x57, 0x9c, 0x2a, 0x64,
+	0xc1, 0x25, 0x81, 0xaa, 0x2f, 0x3e, 0x25, 0x35, 0x07, 0xe4, 0xfc, 0xd4, 0x14, 0xa8, 0x09, 0x62,
+	0x28, 0x26, 0xb8, 0xc0, 0x64, 0x8d, 0x7c, 0xb8, 0xd8, 0xc0, 0x46, 0x15, 0x09, 0x39, 0x71, 0xb1,
+	0x82, 0x59, 0x42, 0x52, 0xa8, 0x0e, 0x45, 0xf6, 0x99, 0x94, 0x34, 0x56, 0x39, 0x88, 0x2b, 0x94,
+	0x18, 0x92, 0xd8, 0xc0, 0xe1, 0x61, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0xd3, 0x0e, 0xb7, 0x2a,
+	0x3d, 0x01, 0x00, 0x00,
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// DriverClient is the client API for Driver service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
+type DriverClient interface {
+	Drive(ctx context.Context, in *DriveRequest, opts ...grpc.CallOption) (*DriveResponse, error)
+}
+
+type driverClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewDriverClient(cc *grpc.ClientConn) DriverClient {
+	return &driverClient{cc}
+}
+
+func (c *driverClient) Drive(ctx context.Context, in *DriveRequest, opts ...grpc.CallOption) (*DriveResponse, error) {
+	out := new(DriveResponse)
+	err := c.cc.Invoke(ctx, "/deltav.model.Driver/Drive", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// DriverServer is the server API for Driver service.
+type DriverServer interface {
+	Drive(context.Context, *DriveRequest) (*DriveResponse, error)
+}
+
+func RegisterDriverServer(s *grpc.Server, srv DriverServer) {
+	s.RegisterService(&_Driver_serviceDesc, srv)
+}
+
+func _Driver_Drive_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(DriveRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(DriverServer).Drive(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/deltav.model.Driver/Drive",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(DriverServer).Drive(ctx, req.(*DriveRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _Driver_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "deltav.model.Driver",
+	HandlerType: (*DriverServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "Drive",
+			Handler:    _Driver_Drive_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "driver.proto",
+}
diff --git a/go/deltav/model/gomodel/mass_object.pb.go b/go/deltav/model/gomodel/mass_object.pb.go
new file mode 100644
index 0000000..5b8c46e
--- /dev/null
+++ b/go/deltav/model/gomodel/mass_object.pb.go
@@ -0,0 +1,185 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: mass_object.proto
+
+package deltav_model
+
+import (
+	fmt "fmt"
+	proto "github.com/golang/protobuf/proto"
+	context "golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
+	math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type GetMassRequest struct {
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetMassRequest) Reset()         { *m = GetMassRequest{} }
+func (m *GetMassRequest) String() string { return proto.CompactTextString(m) }
+func (*GetMassRequest) ProtoMessage()    {}
+func (*GetMassRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_6ff7806aaa97ef70, []int{0}
+}
+
+func (m *GetMassRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_GetMassRequest.Unmarshal(m, b)
+}
+func (m *GetMassRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_GetMassRequest.Marshal(b, m, deterministic)
+}
+func (m *GetMassRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GetMassRequest.Merge(m, src)
+}
+func (m *GetMassRequest) XXX_Size() int {
+	return xxx_messageInfo_GetMassRequest.Size(m)
+}
+func (m *GetMassRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_GetMassRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetMassRequest proto.InternalMessageInfo
+
+type GetMassResponse struct {
+	Kg                   int64    `protobuf:"varint,1,opt,name=kg,proto3" json:"kg,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetMassResponse) Reset()         { *m = GetMassResponse{} }
+func (m *GetMassResponse) String() string { return proto.CompactTextString(m) }
+func (*GetMassResponse) ProtoMessage()    {}
+func (*GetMassResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_6ff7806aaa97ef70, []int{1}
+}
+
+func (m *GetMassResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_GetMassResponse.Unmarshal(m, b)
+}
+func (m *GetMassResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_GetMassResponse.Marshal(b, m, deterministic)
+}
+func (m *GetMassResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GetMassResponse.Merge(m, src)
+}
+func (m *GetMassResponse) XXX_Size() int {
+	return xxx_messageInfo_GetMassResponse.Size(m)
+}
+func (m *GetMassResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_GetMassResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetMassResponse proto.InternalMessageInfo
+
+func (m *GetMassResponse) GetKg() int64 {
+	if m != nil {
+		return m.Kg
+	}
+	return 0
+}
+
+func init() {
+	proto.RegisterType((*GetMassRequest)(nil), "deltav.model.GetMassRequest")
+	proto.RegisterType((*GetMassResponse)(nil), "deltav.model.GetMassResponse")
+}
+
+func init() { proto.RegisterFile("mass_object.proto", fileDescriptor_6ff7806aaa97ef70) }
+
+var fileDescriptor_6ff7806aaa97ef70 = []byte{
+	// 140 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0xcc, 0x4d, 0x2c, 0x2e,
+	0x8e, 0xcf, 0x4f, 0xca, 0x4a, 0x4d, 0x2e, 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x49,
+	0x49, 0xcd, 0x29, 0x49, 0x2c, 0xd3, 0xcb, 0xcd, 0x4f, 0x49, 0xcd, 0x51, 0x12, 0xe0, 0xe2, 0x73,
+	0x4f, 0x2d, 0xf1, 0x4d, 0x2c, 0x2e, 0x0e, 0x4a, 0x2d, 0x2c, 0x4d, 0x2d, 0x2e, 0x51, 0x52, 0xe4,
+	0xe2, 0x87, 0x8b, 0x14, 0x17, 0xe4, 0xe7, 0x15, 0xa7, 0x0a, 0xf1, 0x71, 0x31, 0x65, 0xa7, 0x4b,
+	0x30, 0x2a, 0x30, 0x6a, 0x30, 0x07, 0x31, 0x65, 0xa7, 0x1b, 0x85, 0x71, 0x71, 0x81, 0xe4, 0xfd,
+	0xc1, 0xc6, 0x0a, 0x79, 0x70, 0xb1, 0x43, 0x35, 0x08, 0xc9, 0xe8, 0x21, 0x1b, 0xae, 0x87, 0x6a,
+	0xb2, 0x94, 0x2c, 0x0e, 0x59, 0x88, 0x2d, 0x4a, 0x0c, 0x49, 0x6c, 0x60, 0x17, 0x1a, 0x03, 0x02,
+	0x00, 0x00, 0xff, 0xff, 0x2f, 0x60, 0xf9, 0x96, 0xb6, 0x00, 0x00, 0x00,
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// MassObjectClient is the client API for MassObject service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
+type MassObjectClient interface {
+	GetMass(ctx context.Context, in *GetMassRequest, opts ...grpc.CallOption) (*GetMassResponse, error)
+}
+
+type massObjectClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewMassObjectClient(cc *grpc.ClientConn) MassObjectClient {
+	return &massObjectClient{cc}
+}
+
+func (c *massObjectClient) GetMass(ctx context.Context, in *GetMassRequest, opts ...grpc.CallOption) (*GetMassResponse, error) {
+	out := new(GetMassResponse)
+	err := c.cc.Invoke(ctx, "/deltav.model.MassObject/GetMass", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// MassObjectServer is the server API for MassObject service.
+type MassObjectServer interface {
+	GetMass(context.Context, *GetMassRequest) (*GetMassResponse, error)
+}
+
+func RegisterMassObjectServer(s *grpc.Server, srv MassObjectServer) {
+	s.RegisterService(&_MassObject_serviceDesc, srv)
+}
+
+func _MassObject_GetMass_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GetMassRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MassObjectServer).GetMass(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/deltav.model.MassObject/GetMass",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MassObjectServer).GetMass(ctx, req.(*GetMassRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _MassObject_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "deltav.model.MassObject",
+	HandlerType: (*MassObjectServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "GetMass",
+			Handler:    _MassObject_GetMass_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "mass_object.proto",
+}
diff --git a/go/deltav/model/gomodel/position.go b/go/deltav/model/gomodel/position.go
new file mode 100644
index 0000000..fb286cd
--- /dev/null
+++ b/go/deltav/model/gomodel/position.go
@@ -0,0 +1,25 @@
+package deltav_model
+
+/*
+This file is a value-added addition helper functions on the position/vector struct.
+TODO: Decouple wire interface with go working model.
+*/
+import "math"
+
+// MagnitudeSquared takes a Vector3 and gets the magnitude squared.
+// Magnitude will not be written because Square root is expensive and
+// one should be cognisant of expensive operations so this is fast by
+// default.
+func (p *Vector3) MagnitudeSquared() float64 {
+	return math.Pow(p.X, 2) + math.Pow(p.Y, 2) + math.Pow(p.Z, 2)
+}
+
+// Subtract gets the difference between two vectors.
+func (p *Vector3) Subtract(n *Vector3) *Vector3 {
+	return &Vector3{X: p.X - n.X, Y: p.Y - n.Y, Z: p.Z - n.Z}
+}
+
+// Subtract gets the difference between two positions.
+func (p *Position) Subtract(n *Position) *Position {
+	return &Position{Position: p.Position.Subtract(n.Position), T: p.T - n.T}
+}
diff --git a/go/deltav/model/gomodel/position.pb.go b/go/deltav/model/gomodel/position.pb.go
new file mode 100644
index 0000000..d170e3b
--- /dev/null
+++ b/go/deltav/model/gomodel/position.pb.go
@@ -0,0 +1,146 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: position.proto
+
+package deltav_model
+
+import (
+	fmt "fmt"
+	proto "github.com/golang/protobuf/proto"
+	math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// Vector3 is a 3D vector. Double is used as compared to float
+// despite being 30% slower because the Math library uses Doubles.
+type Vector3 struct {
+	X                    float64  `protobuf:"fixed64,1,opt,name=X,proto3" json:"X,omitempty"`
+	Y                    float64  `protobuf:"fixed64,2,opt,name=Y,proto3" json:"Y,omitempty"`
+	Z                    float64  `protobuf:"fixed64,3,opt,name=Z,proto3" json:"Z,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Vector3) Reset()         { *m = Vector3{} }
+func (m *Vector3) String() string { return proto.CompactTextString(m) }
+func (*Vector3) ProtoMessage()    {}
+func (*Vector3) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56e266f1a28a7893, []int{0}
+}
+
+func (m *Vector3) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Vector3.Unmarshal(m, b)
+}
+func (m *Vector3) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Vector3.Marshal(b, m, deterministic)
+}
+func (m *Vector3) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Vector3.Merge(m, src)
+}
+func (m *Vector3) XXX_Size() int {
+	return xxx_messageInfo_Vector3.Size(m)
+}
+func (m *Vector3) XXX_DiscardUnknown() {
+	xxx_messageInfo_Vector3.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Vector3 proto.InternalMessageInfo
+
+func (m *Vector3) GetX() float64 {
+	if m != nil {
+		return m.X
+	}
+	return 0
+}
+
+func (m *Vector3) GetY() float64 {
+	if m != nil {
+		return m.Y
+	}
+	return 0
+}
+
+func (m *Vector3) GetZ() float64 {
+	if m != nil {
+		return m.Z
+	}
+	return 0
+}
+
+// Position is a Vector3 spacial position combined with time.
+type Position struct {
+	Position             *Vector3 `protobuf:"bytes,1,opt,name=position,proto3" json:"position,omitempty"`
+	T                    int64    `protobuf:"varint,2,opt,name=T,proto3" json:"T,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Position) Reset()         { *m = Position{} }
+func (m *Position) String() string { return proto.CompactTextString(m) }
+func (*Position) ProtoMessage()    {}
+func (*Position) Descriptor() ([]byte, []int) {
+	return fileDescriptor_56e266f1a28a7893, []int{1}
+}
+
+func (m *Position) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Position.Unmarshal(m, b)
+}
+func (m *Position) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Position.Marshal(b, m, deterministic)
+}
+func (m *Position) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Position.Merge(m, src)
+}
+func (m *Position) XXX_Size() int {
+	return xxx_messageInfo_Position.Size(m)
+}
+func (m *Position) XXX_DiscardUnknown() {
+	xxx_messageInfo_Position.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Position proto.InternalMessageInfo
+
+func (m *Position) GetPosition() *Vector3 {
+	if m != nil {
+		return m.Position
+	}
+	return nil
+}
+
+func (m *Position) GetT() int64 {
+	if m != nil {
+		return m.T
+	}
+	return 0
+}
+
+func init() {
+	proto.RegisterType((*Vector3)(nil), "deltav.model.Vector3")
+	proto.RegisterType((*Position)(nil), "deltav.model.Position")
+}
+
+func init() { proto.RegisterFile("position.proto", fileDescriptor_56e266f1a28a7893) }
+
+var fileDescriptor_56e266f1a28a7893 = []byte{
+	// 136 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x2b, 0xc8, 0x2f, 0xce,
+	0x2c, 0xc9, 0xcc, 0xcf, 0xd3, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x49, 0x49, 0xcd, 0x29,
+	0x49, 0x2c, 0xd3, 0xcb, 0xcd, 0x4f, 0x49, 0xcd, 0x51, 0x32, 0xe6, 0x62, 0x0f, 0x4b, 0x4d, 0x2e,
+	0xc9, 0x2f, 0x32, 0x16, 0xe2, 0xe1, 0x62, 0x8c, 0x90, 0x60, 0x54, 0x60, 0xd4, 0x60, 0x0c, 0x62,
+	0x8c, 0x00, 0xf1, 0x22, 0x25, 0x98, 0x20, 0xbc, 0x48, 0x10, 0x2f, 0x4a, 0x82, 0x19, 0xc2, 0x8b,
+	0x52, 0xf2, 0xe6, 0xe2, 0x08, 0x80, 0x1a, 0x2a, 0x64, 0xc8, 0xc5, 0x01, 0xb3, 0x00, 0xac, 0x99,
+	0xdb, 0x48, 0x54, 0x0f, 0xd9, 0x06, 0x3d, 0xa8, 0xf1, 0x41, 0x70, 0x65, 0x20, 0xc3, 0x42, 0xc0,
+	0x46, 0x33, 0x07, 0x31, 0x86, 0x24, 0xb1, 0x81, 0x9d, 0x65, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff,
+	0x7e, 0xae, 0xb2, 0x40, 0xa8, 0x00, 0x00, 0x00,
+}
diff --git a/go/deltav/model/gomodel/reactor.pb.go b/go/deltav/model/gomodel/reactor.pb.go
new file mode 100644
index 0000000..b081f44
--- /dev/null
+++ b/go/deltav/model/gomodel/reactor.pb.go
@@ -0,0 +1,282 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: reactor.proto
+
+package deltav_model
+
+import (
+	fmt "fmt"
+	proto "github.com/golang/protobuf/proto"
+	context "golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
+	math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type ReactorOutput_Type int32
+
+const (
+	ReactorOutput_UNKNOWN        ReactorOutput_Type = 0
+	ReactorOutput_ENERGY_TJOULES ReactorOutput_Type = 1
+	ReactorOutput_HEAT_TJOULES   ReactorOutput_Type = 2
+	ReactorOutput_GAMMA_TJOULES  ReactorOutput_Type = 3
+)
+
+var ReactorOutput_Type_name = map[int32]string{
+	0: "UNKNOWN",
+	1: "ENERGY_TJOULES",
+	2: "HEAT_TJOULES",
+	3: "GAMMA_TJOULES",
+}
+
+var ReactorOutput_Type_value = map[string]int32{
+	"UNKNOWN":        0,
+	"ENERGY_TJOULES": 1,
+	"HEAT_TJOULES":   2,
+	"GAMMA_TJOULES":  3,
+}
+
+func (x ReactorOutput_Type) String() string {
+	return proto.EnumName(ReactorOutput_Type_name, int32(x))
+}
+
+func (ReactorOutput_Type) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_2a9d77bb3db9aa96, []int{1, 0}
+}
+
+type ReactRequest struct {
+	DesiredEnergyTeraJoules float64  `protobuf:"fixed64,1,opt,name=desiredEnergyTeraJoules,proto3" json:"desiredEnergyTeraJoules,omitempty"`
+	XXX_NoUnkeyedLiteral    struct{} `json:"-"`
+	XXX_unrecognized        []byte   `json:"-"`
+	XXX_sizecache           int32    `json:"-"`
+}
+
+func (m *ReactRequest) Reset()         { *m = ReactRequest{} }
+func (m *ReactRequest) String() string { return proto.CompactTextString(m) }
+func (*ReactRequest) ProtoMessage()    {}
+func (*ReactRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_2a9d77bb3db9aa96, []int{0}
+}
+
+func (m *ReactRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ReactRequest.Unmarshal(m, b)
+}
+func (m *ReactRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ReactRequest.Marshal(b, m, deterministic)
+}
+func (m *ReactRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReactRequest.Merge(m, src)
+}
+func (m *ReactRequest) XXX_Size() int {
+	return xxx_messageInfo_ReactRequest.Size(m)
+}
+func (m *ReactRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_ReactRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ReactRequest proto.InternalMessageInfo
+
+func (m *ReactRequest) GetDesiredEnergyTeraJoules() float64 {
+	if m != nil {
+		return m.DesiredEnergyTeraJoules
+	}
+	return 0
+}
+
+type ReactorOutput struct {
+	Type                 ReactorOutput_Type `protobuf:"varint,1,opt,name=type,proto3,enum=deltav.model.ReactorOutput_Type" json:"type,omitempty"`
+	Amount               float64            `protobuf:"fixed64,2,opt,name=amount,proto3" json:"amount,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
+	XXX_unrecognized     []byte             `json:"-"`
+	XXX_sizecache        int32              `json:"-"`
+}
+
+func (m *ReactorOutput) Reset()         { *m = ReactorOutput{} }
+func (m *ReactorOutput) String() string { return proto.CompactTextString(m) }
+func (*ReactorOutput) ProtoMessage()    {}
+func (*ReactorOutput) Descriptor() ([]byte, []int) {
+	return fileDescriptor_2a9d77bb3db9aa96, []int{1}
+}
+
+func (m *ReactorOutput) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ReactorOutput.Unmarshal(m, b)
+}
+func (m *ReactorOutput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ReactorOutput.Marshal(b, m, deterministic)
+}
+func (m *ReactorOutput) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReactorOutput.Merge(m, src)
+}
+func (m *ReactorOutput) XXX_Size() int {
+	return xxx_messageInfo_ReactorOutput.Size(m)
+}
+func (m *ReactorOutput) XXX_DiscardUnknown() {
+	xxx_messageInfo_ReactorOutput.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ReactorOutput proto.InternalMessageInfo
+
+func (m *ReactorOutput) GetType() ReactorOutput_Type {
+	if m != nil {
+		return m.Type
+	}
+	return ReactorOutput_UNKNOWN
+}
+
+func (m *ReactorOutput) GetAmount() float64 {
+	if m != nil {
+		return m.Amount
+	}
+	return 0
+}
+
+type ReactResponse struct {
+	Outputs              []*ReactorOutput `protobuf:"bytes,1,rep,name=outputs,proto3" json:"outputs,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+	XXX_unrecognized     []byte           `json:"-"`
+	XXX_sizecache        int32            `json:"-"`
+}
+
+func (m *ReactResponse) Reset()         { *m = ReactResponse{} }
+func (m *ReactResponse) String() string { return proto.CompactTextString(m) }
+func (*ReactResponse) ProtoMessage()    {}
+func (*ReactResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_2a9d77bb3db9aa96, []int{2}
+}
+
+func (m *ReactResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ReactResponse.Unmarshal(m, b)
+}
+func (m *ReactResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ReactResponse.Marshal(b, m, deterministic)
+}
+func (m *ReactResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReactResponse.Merge(m, src)
+}
+func (m *ReactResponse) XXX_Size() int {
+	return xxx_messageInfo_ReactResponse.Size(m)
+}
+func (m *ReactResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_ReactResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ReactResponse proto.InternalMessageInfo
+
+func (m *ReactResponse) GetOutputs() []*ReactorOutput {
+	if m != nil {
+		return m.Outputs
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterEnum("deltav.model.ReactorOutput_Type", ReactorOutput_Type_name, ReactorOutput_Type_value)
+	proto.RegisterType((*ReactRequest)(nil), "deltav.model.ReactRequest")
+	proto.RegisterType((*ReactorOutput)(nil), "deltav.model.ReactorOutput")
+	proto.RegisterType((*ReactResponse)(nil), "deltav.model.ReactResponse")
+}
+
+func init() { proto.RegisterFile("reactor.proto", fileDescriptor_2a9d77bb3db9aa96) }
+
+var fileDescriptor_2a9d77bb3db9aa96 = []byte{
+	// 281 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x91, 0x41, 0x4b, 0xc3, 0x40,
+	0x10, 0x85, 0x9b, 0xb6, 0xb6, 0x30, 0x4d, 0x4a, 0x9c, 0x83, 0x96, 0xf6, 0x52, 0x72, 0xea, 0x29,
+	0x87, 0xa8, 0xe0, 0x35, 0x42, 0x6c, 0xa9, 0x4d, 0x02, 0x6b, 0x8a, 0x78, 0x92, 0x68, 0x06, 0x11,
+	0xd2, 0x6c, 0xdc, 0xec, 0x0a, 0xf9, 0x4d, 0xfe, 0x49, 0xc9, 0x36, 0x16, 0x85, 0xea, 0x6d, 0x77,
+	0xde, 0x7b, 0xbc, 0x6f, 0x77, 0xc0, 0x12, 0x94, 0xbe, 0x48, 0x2e, 0xdc, 0x52, 0x70, 0xc9, 0xd1,
+	0xcc, 0x28, 0x97, 0xe9, 0x87, 0xbb, 0xe3, 0x19, 0xe5, 0xce, 0x0a, 0x4c, 0xd6, 0xc8, 0x8c, 0xde,
+	0x15, 0x55, 0x12, 0xaf, 0xe1, 0x3c, 0xa3, 0xea, 0x4d, 0x50, 0x16, 0x14, 0x24, 0x5e, 0xeb, 0x84,
+	0x44, 0xba, 0xe6, 0x2a, 0xa7, 0x6a, 0x62, 0xcc, 0x8d, 0x85, 0xc1, 0xfe, 0x92, 0x9d, 0x4f, 0x03,
+	0x2c, 0xb6, 0x6f, 0x8a, 0x95, 0x2c, 0x95, 0xc4, 0x4b, 0xe8, 0xcb, 0xba, 0x24, 0x1d, 0x1c, 0x7b,
+	0x73, 0xf7, 0x67, 0xb1, 0xfb, 0xcb, 0xea, 0x26, 0x75, 0x49, 0x4c, 0xbb, 0xf1, 0x0c, 0x06, 0xe9,
+	0x8e, 0xab, 0x42, 0x4e, 0xba, 0xba, 0xb0, 0xbd, 0x39, 0x1b, 0xe8, 0x37, 0x2e, 0x1c, 0xc1, 0x70,
+	0x1b, 0xdd, 0x45, 0xf1, 0x43, 0x64, 0x77, 0x10, 0x61, 0x1c, 0x44, 0x01, 0x5b, 0x3e, 0x3e, 0x25,
+	0xeb, 0x78, 0xbb, 0x09, 0xee, 0x6d, 0x03, 0x6d, 0x30, 0x57, 0x81, 0x9f, 0x1c, 0x26, 0x5d, 0x3c,
+	0x05, 0x6b, 0xe9, 0x87, 0xa1, 0x7f, 0x18, 0xf5, 0x9c, 0xdb, 0x16, 0x96, 0x51, 0x55, 0xf2, 0xa2,
+	0x22, 0xbc, 0x82, 0x21, 0xd7, 0x2c, 0xcd, 0x43, 0x7b, 0x8b, 0x91, 0x37, 0xfb, 0x87, 0x97, 0x7d,
+	0x7b, 0xbd, 0x10, 0x86, 0xad, 0x82, 0x37, 0x70, 0xa2, 0x8f, 0x38, 0x3d, 0x92, 0x6c, 0xff, 0x77,
+	0x3a, 0x3b, 0xaa, 0xed, 0x19, 0x9c, 0xce, 0xf3, 0x40, 0xef, 0xe8, 0xe2, 0x2b, 0x00, 0x00, 0xff,
+	0xff, 0x69, 0x69, 0x62, 0x60, 0xb4, 0x01, 0x00, 0x00,
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// ReactorClient is the client API for Reactor service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
+type ReactorClient interface {
+	React(ctx context.Context, in *ReactRequest, opts ...grpc.CallOption) (*ReactResponse, error)
+}
+
+type reactorClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewReactorClient(cc *grpc.ClientConn) ReactorClient {
+	return &reactorClient{cc}
+}
+
+func (c *reactorClient) React(ctx context.Context, in *ReactRequest, opts ...grpc.CallOption) (*ReactResponse, error) {
+	out := new(ReactResponse)
+	err := c.cc.Invoke(ctx, "/deltav.model.Reactor/React", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// ReactorServer is the server API for Reactor service.
+type ReactorServer interface {
+	React(context.Context, *ReactRequest) (*ReactResponse, error)
+}
+
+func RegisterReactorServer(s *grpc.Server, srv ReactorServer) {
+	s.RegisterService(&_Reactor_serviceDesc, srv)
+}
+
+func _Reactor_React_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ReactRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ReactorServer).React(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/deltav.model.Reactor/React",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ReactorServer).React(ctx, req.(*ReactRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _Reactor_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "deltav.model.Reactor",
+	HandlerType: (*ReactorServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "React",
+			Handler:    _Reactor_React_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "reactor.proto",
+}
diff --git a/go/deltav/model/gomodel/storage.pb.go b/go/deltav/model/gomodel/storage.pb.go
new file mode 100644
index 0000000..741cd13
--- /dev/null
+++ b/go/deltav/model/gomodel/storage.pb.go
@@ -0,0 +1,547 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: storage.proto
+
+package deltav_model
+
+import (
+	fmt "fmt"
+	proto "github.com/golang/protobuf/proto"
+	context "golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
+	math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type StorageType int32
+
+const (
+	StorageType_UNKNOWN_STORAGE_TYPE StorageType = 0
+	StorageType_HELIUM3_KG           StorageType = 1
+	StorageType_DEUTERIUM_KG         StorageType = 2
+	StorageType_WATER_KG             StorageType = 3
+	StorageType_ELECTRIC_JOULES      StorageType = 4
+	StorageType_HEAT_JOULES          StorageType = 5
+)
+
+var StorageType_name = map[int32]string{
+	0: "UNKNOWN_STORAGE_TYPE",
+	1: "HELIUM3_KG",
+	2: "DEUTERIUM_KG",
+	3: "WATER_KG",
+	4: "ELECTRIC_JOULES",
+	5: "HEAT_JOULES",
+}
+
+var StorageType_value = map[string]int32{
+	"UNKNOWN_STORAGE_TYPE": 0,
+	"HELIUM3_KG":           1,
+	"DEUTERIUM_KG":         2,
+	"WATER_KG":             3,
+	"ELECTRIC_JOULES":      4,
+	"HEAT_JOULES":          5,
+}
+
+func (x StorageType) String() string {
+	return proto.EnumName(StorageType_name, int32(x))
+}
+
+func (StorageType) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_0d2c4ccf1453ffdb, []int{0}
+}
+
+type Storage struct {
+	Amount               float64     `protobuf:"fixed64,1,opt,name=amount,proto3" json:"amount,omitempty"`
+	Type                 StorageType `protobuf:"varint,2,opt,name=type,proto3,enum=deltav.model.StorageType" json:"type,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
+	XXX_unrecognized     []byte      `json:"-"`
+	XXX_sizecache        int32       `json:"-"`
+}
+
+func (m *Storage) Reset()         { *m = Storage{} }
+func (m *Storage) String() string { return proto.CompactTextString(m) }
+func (*Storage) ProtoMessage()    {}
+func (*Storage) Descriptor() ([]byte, []int) {
+	return fileDescriptor_0d2c4ccf1453ffdb, []int{0}
+}
+
+func (m *Storage) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Storage.Unmarshal(m, b)
+}
+func (m *Storage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Storage.Marshal(b, m, deterministic)
+}
+func (m *Storage) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Storage.Merge(m, src)
+}
+func (m *Storage) XXX_Size() int {
+	return xxx_messageInfo_Storage.Size(m)
+}
+func (m *Storage) XXX_DiscardUnknown() {
+	xxx_messageInfo_Storage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Storage proto.InternalMessageInfo
+
+func (m *Storage) GetAmount() float64 {
+	if m != nil {
+		return m.Amount
+	}
+	return 0
+}
+
+func (m *Storage) GetType() StorageType {
+	if m != nil {
+		return m.Type
+	}
+	return StorageType_UNKNOWN_STORAGE_TYPE
+}
+
+type AddStorageRequest struct {
+	Storage              *Storage `protobuf:"bytes,1,opt,name=storage,proto3" json:"storage,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *AddStorageRequest) Reset()         { *m = AddStorageRequest{} }
+func (m *AddStorageRequest) String() string { return proto.CompactTextString(m) }
+func (*AddStorageRequest) ProtoMessage()    {}
+func (*AddStorageRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_0d2c4ccf1453ffdb, []int{1}
+}
+
+func (m *AddStorageRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_AddStorageRequest.Unmarshal(m, b)
+}
+func (m *AddStorageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_AddStorageRequest.Marshal(b, m, deterministic)
+}
+func (m *AddStorageRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_AddStorageRequest.Merge(m, src)
+}
+func (m *AddStorageRequest) XXX_Size() int {
+	return xxx_messageInfo_AddStorageRequest.Size(m)
+}
+func (m *AddStorageRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_AddStorageRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AddStorageRequest proto.InternalMessageInfo
+
+func (m *AddStorageRequest) GetStorage() *Storage {
+	if m != nil {
+		return m.Storage
+	}
+	return nil
+}
+
+type AddStorageResponse struct {
+	Storage              *Storage `protobuf:"bytes,1,opt,name=storage,proto3" json:"storage,omitempty"`
+	Err                  string   `protobuf:"bytes,2,opt,name=err,proto3" json:"err,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *AddStorageResponse) Reset()         { *m = AddStorageResponse{} }
+func (m *AddStorageResponse) String() string { return proto.CompactTextString(m) }
+func (*AddStorageResponse) ProtoMessage()    {}
+func (*AddStorageResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_0d2c4ccf1453ffdb, []int{2}
+}
+
+func (m *AddStorageResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_AddStorageResponse.Unmarshal(m, b)
+}
+func (m *AddStorageResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_AddStorageResponse.Marshal(b, m, deterministic)
+}
+func (m *AddStorageResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_AddStorageResponse.Merge(m, src)
+}
+func (m *AddStorageResponse) XXX_Size() int {
+	return xxx_messageInfo_AddStorageResponse.Size(m)
+}
+func (m *AddStorageResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_AddStorageResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AddStorageResponse proto.InternalMessageInfo
+
+func (m *AddStorageResponse) GetStorage() *Storage {
+	if m != nil {
+		return m.Storage
+	}
+	return nil
+}
+
+func (m *AddStorageResponse) GetErr() string {
+	if m != nil {
+		return m.Err
+	}
+	return ""
+}
+
+type WithdrawStorageRequest struct {
+	Storage              *Storage `protobuf:"bytes,1,opt,name=storage,proto3" json:"storage,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *WithdrawStorageRequest) Reset()         { *m = WithdrawStorageRequest{} }
+func (m *WithdrawStorageRequest) String() string { return proto.CompactTextString(m) }
+func (*WithdrawStorageRequest) ProtoMessage()    {}
+func (*WithdrawStorageRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_0d2c4ccf1453ffdb, []int{3}
+}
+
+func (m *WithdrawStorageRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_WithdrawStorageRequest.Unmarshal(m, b)
+}
+func (m *WithdrawStorageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_WithdrawStorageRequest.Marshal(b, m, deterministic)
+}
+func (m *WithdrawStorageRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_WithdrawStorageRequest.Merge(m, src)
+}
+func (m *WithdrawStorageRequest) XXX_Size() int {
+	return xxx_messageInfo_WithdrawStorageRequest.Size(m)
+}
+func (m *WithdrawStorageRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_WithdrawStorageRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_WithdrawStorageRequest proto.InternalMessageInfo
+
+func (m *WithdrawStorageRequest) GetStorage() *Storage {
+	if m != nil {
+		return m.Storage
+	}
+	return nil
+}
+
+type WithdrawStorageResponse struct {
+	Storage              *Storage `protobuf:"bytes,1,opt,name=storage,proto3" json:"storage,omitempty"`
+	Err                  string   `protobuf:"bytes,2,opt,name=err,proto3" json:"err,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *WithdrawStorageResponse) Reset()         { *m = WithdrawStorageResponse{} }
+func (m *WithdrawStorageResponse) String() string { return proto.CompactTextString(m) }
+func (*WithdrawStorageResponse) ProtoMessage()    {}
+func (*WithdrawStorageResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_0d2c4ccf1453ffdb, []int{4}
+}
+
+func (m *WithdrawStorageResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_WithdrawStorageResponse.Unmarshal(m, b)
+}
+func (m *WithdrawStorageResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_WithdrawStorageResponse.Marshal(b, m, deterministic)
+}
+func (m *WithdrawStorageResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_WithdrawStorageResponse.Merge(m, src)
+}
+func (m *WithdrawStorageResponse) XXX_Size() int {
+	return xxx_messageInfo_WithdrawStorageResponse.Size(m)
+}
+func (m *WithdrawStorageResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_WithdrawStorageResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_WithdrawStorageResponse proto.InternalMessageInfo
+
+func (m *WithdrawStorageResponse) GetStorage() *Storage {
+	if m != nil {
+		return m.Storage
+	}
+	return nil
+}
+
+func (m *WithdrawStorageResponse) GetErr() string {
+	if m != nil {
+		return m.Err
+	}
+	return ""
+}
+
+type StorageStatusRequest struct {
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *StorageStatusRequest) Reset()         { *m = StorageStatusRequest{} }
+func (m *StorageStatusRequest) String() string { return proto.CompactTextString(m) }
+func (*StorageStatusRequest) ProtoMessage()    {}
+func (*StorageStatusRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_0d2c4ccf1453ffdb, []int{5}
+}
+
+func (m *StorageStatusRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_StorageStatusRequest.Unmarshal(m, b)
+}
+func (m *StorageStatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_StorageStatusRequest.Marshal(b, m, deterministic)
+}
+func (m *StorageStatusRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_StorageStatusRequest.Merge(m, src)
+}
+func (m *StorageStatusRequest) XXX_Size() int {
+	return xxx_messageInfo_StorageStatusRequest.Size(m)
+}
+func (m *StorageStatusRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_StorageStatusRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_StorageStatusRequest proto.InternalMessageInfo
+
+type StorageStatusResponse struct {
+	Capacity             float64     `protobuf:"fixed64,1,opt,name=capacity,proto3" json:"capacity,omitempty"`
+	Current              float64     `protobuf:"fixed64,2,opt,name=current,proto3" json:"current,omitempty"`
+	Type                 StorageType `protobuf:"varint,3,opt,name=type,proto3,enum=deltav.model.StorageType" json:"type,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
+	XXX_unrecognized     []byte      `json:"-"`
+	XXX_sizecache        int32       `json:"-"`
+}
+
+func (m *StorageStatusResponse) Reset()         { *m = StorageStatusResponse{} }
+func (m *StorageStatusResponse) String() string { return proto.CompactTextString(m) }
+func (*StorageStatusResponse) ProtoMessage()    {}
+func (*StorageStatusResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_0d2c4ccf1453ffdb, []int{6}
+}
+
+func (m *StorageStatusResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_StorageStatusResponse.Unmarshal(m, b)
+}
+func (m *StorageStatusResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_StorageStatusResponse.Marshal(b, m, deterministic)
+}
+func (m *StorageStatusResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_StorageStatusResponse.Merge(m, src)
+}
+func (m *StorageStatusResponse) XXX_Size() int {
+	return xxx_messageInfo_StorageStatusResponse.Size(m)
+}
+func (m *StorageStatusResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_StorageStatusResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_StorageStatusResponse proto.InternalMessageInfo
+
+func (m *StorageStatusResponse) GetCapacity() float64 {
+	if m != nil {
+		return m.Capacity
+	}
+	return 0
+}
+
+func (m *StorageStatusResponse) GetCurrent() float64 {
+	if m != nil {
+		return m.Current
+	}
+	return 0
+}
+
+func (m *StorageStatusResponse) GetType() StorageType {
+	if m != nil {
+		return m.Type
+	}
+	return StorageType_UNKNOWN_STORAGE_TYPE
+}
+
+func init() {
+	proto.RegisterEnum("deltav.model.StorageType", StorageType_name, StorageType_value)
+	proto.RegisterType((*Storage)(nil), "deltav.model.Storage")
+	proto.RegisterType((*AddStorageRequest)(nil), "deltav.model.AddStorageRequest")
+	proto.RegisterType((*AddStorageResponse)(nil), "deltav.model.AddStorageResponse")
+	proto.RegisterType((*WithdrawStorageRequest)(nil), "deltav.model.WithdrawStorageRequest")
+	proto.RegisterType((*WithdrawStorageResponse)(nil), "deltav.model.WithdrawStorageResponse")
+	proto.RegisterType((*StorageStatusRequest)(nil), "deltav.model.StorageStatusRequest")
+	proto.RegisterType((*StorageStatusResponse)(nil), "deltav.model.StorageStatusResponse")
+}
+
+func init() { proto.RegisterFile("storage.proto", fileDescriptor_0d2c4ccf1453ffdb) }
+
+var fileDescriptor_0d2c4ccf1453ffdb = []byte{
+	// 419 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x53, 0x7f, 0x6f, 0x93, 0x50,
+	0x14, 0x1d, 0xed, 0x6c, 0xe7, 0x6d, 0x5d, 0xf1, 0xba, 0x55, 0xe4, 0x1f, 0x1b, 0xd4, 0x64, 0x31,
+	0x11, 0x93, 0xee, 0x13, 0x90, 0xed, 0x65, 0xc3, 0x75, 0xed, 0x7c, 0x40, 0x88, 0x89, 0x09, 0x3e,
+	0xcb, 0x8b, 0x36, 0xb6, 0x80, 0xf0, 0xd0, 0x34, 0xd1, 0xcf, 0xe1, 0xd7, 0x35, 0xa5, 0x8f, 0xfe,
+	0xf6, 0x57, 0xdc, 0x7f, 0x9c, 0xc3, 0xb9, 0xe7, 0x1e, 0xde, 0x79, 0xc0, 0xbd, 0x4c, 0xc4, 0x29,
+	0xfb, 0xc0, 0xcd, 0x24, 0x8d, 0x45, 0x8c, 0xcd, 0x90, 0x8f, 0x05, 0xfb, 0x62, 0x4e, 0xe2, 0x90,
+	0x8f, 0x8d, 0x1b, 0xa8, 0x3b, 0xf3, 0xd7, 0xd8, 0x86, 0x1a, 0x9b, 0xc4, 0x79, 0x24, 0x34, 0xa5,
+	0xa3, 0x9c, 0x28, 0x54, 0x22, 0x7c, 0x01, 0xfb, 0x62, 0x9a, 0x70, 0xad, 0xd2, 0x51, 0x4e, 0x0e,
+	0xbb, 0x8f, 0xcc, 0xd5, 0x79, 0x53, 0x0e, 0xbb, 0xd3, 0x84, 0xd3, 0x42, 0x66, 0x9c, 0xc3, 0x7d,
+	0x2b, 0x0c, 0x25, 0x4f, 0xf9, 0xe7, 0x9c, 0x67, 0x02, 0x5f, 0x42, 0x5d, 0xa6, 0x28, 0xcc, 0x1b,
+	0xdd, 0xe3, 0x9d, 0x36, 0xb4, 0x54, 0x19, 0x3e, 0xe0, 0xaa, 0x4b, 0x96, 0xc4, 0x51, 0xc6, 0xff,
+	0xd9, 0x06, 0x55, 0xa8, 0xf2, 0x34, 0x2d, 0xa2, 0xdf, 0xa5, 0xb3, 0x47, 0xc3, 0x86, 0xb6, 0x3f,
+	0x12, 0x1f, 0xc3, 0x94, 0x7d, 0xfd, 0xdf, 0x8c, 0x6f, 0xe1, 0xe1, 0x96, 0xd5, 0xed, 0x05, 0x6d,
+	0xc3, 0x91, 0x54, 0x39, 0x82, 0x89, 0x3c, 0x93, 0x31, 0x8d, 0x6f, 0x70, 0xbc, 0xc1, 0xcb, 0x9d,
+	0x3a, 0x1c, 0x0c, 0x59, 0xc2, 0x86, 0x23, 0x31, 0x95, 0x0d, 0x2e, 0x30, 0x6a, 0x50, 0x1f, 0xe6,
+	0x69, 0xca, 0x23, 0x51, 0xac, 0x50, 0x68, 0x09, 0x17, 0xed, 0x56, 0xff, 0xaa, 0xdd, 0xe7, 0xdf,
+	0xa1, 0xb1, 0x42, 0xa2, 0x06, 0x47, 0x5e, 0xff, 0xaa, 0x3f, 0xf0, 0xfb, 0x81, 0xe3, 0x0e, 0xa8,
+	0x75, 0x41, 0x02, 0xf7, 0xcd, 0x0d, 0x51, 0xf7, 0xf0, 0x10, 0xe0, 0x92, 0xf4, 0x6c, 0xef, 0xfa,
+	0x34, 0xb8, 0xba, 0x50, 0x15, 0x54, 0xa1, 0x79, 0x4e, 0x3c, 0x97, 0x50, 0xdb, 0xbb, 0x9e, 0x31,
+	0x15, 0x6c, 0xc2, 0x81, 0x6f, 0xb9, 0x84, 0xce, 0x50, 0x15, 0x1f, 0x40, 0x8b, 0xf4, 0xc8, 0x99,
+	0x4b, 0xed, 0xb3, 0xe0, 0xd5, 0xc0, 0xeb, 0x11, 0x47, 0xdd, 0xc7, 0x16, 0x34, 0x2e, 0x89, 0xe5,
+	0x96, 0xc4, 0x9d, 0xee, 0x8f, 0xca, 0x72, 0x3f, 0x8b, 0x3e, 0xe1, 0x3b, 0x68, 0x6d, 0x54, 0x80,
+	0x4f, 0xd7, 0x3f, 0x61, 0x77, 0xd9, 0xfa, 0xb3, 0x3f, 0xa8, 0xe6, 0x67, 0x6a, 0xec, 0xe1, 0x6b,
+	0x80, 0xe5, 0x45, 0xc4, 0xc7, 0xeb, 0x63, 0x5b, 0x17, 0x5d, 0xef, 0xfc, 0x5a, 0xb0, 0xb0, 0x74,
+	0xa0, 0x36, 0xaf, 0x0e, 0x8d, 0x9d, 0xc7, 0xbd, 0xd6, 0xb7, 0xfe, 0xe4, 0xb7, 0x9a, 0xd2, 0xf4,
+	0x7d, 0xad, 0xf8, 0xbb, 0x4f, 0x7f, 0x06, 0x00, 0x00, 0xff, 0xff, 0x9d, 0xda, 0xb4, 0x5d, 0xee,
+	0x03, 0x00, 0x00,
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// StorageTankClient is the client API for StorageTank service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
+type StorageTankClient interface {
+	WithdrawStorage(ctx context.Context, in *WithdrawStorageRequest, opts ...grpc.CallOption) (*WithdrawStorageResponse, error)
+	AddStorage(ctx context.Context, in *AddStorageRequest, opts ...grpc.CallOption) (*AddStorageResponse, error)
+	Status(ctx context.Context, in *StorageStatusRequest, opts ...grpc.CallOption) (*StorageStatusResponse, error)
+}
+
+type storageTankClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewStorageTankClient(cc *grpc.ClientConn) StorageTankClient {
+	return &storageTankClient{cc}
+}
+
+func (c *storageTankClient) WithdrawStorage(ctx context.Context, in *WithdrawStorageRequest, opts ...grpc.CallOption) (*WithdrawStorageResponse, error) {
+	out := new(WithdrawStorageResponse)
+	err := c.cc.Invoke(ctx, "/deltav.model.StorageTank/WithdrawStorage", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *storageTankClient) AddStorage(ctx context.Context, in *AddStorageRequest, opts ...grpc.CallOption) (*AddStorageResponse, error) {
+	out := new(AddStorageResponse)
+	err := c.cc.Invoke(ctx, "/deltav.model.StorageTank/AddStorage", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *storageTankClient) Status(ctx context.Context, in *StorageStatusRequest, opts ...grpc.CallOption) (*StorageStatusResponse, error) {
+	out := new(StorageStatusResponse)
+	err := c.cc.Invoke(ctx, "/deltav.model.StorageTank/Status", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// StorageTankServer is the server API for StorageTank service.
+type StorageTankServer interface {
+	WithdrawStorage(context.Context, *WithdrawStorageRequest) (*WithdrawStorageResponse, error)
+	AddStorage(context.Context, *AddStorageRequest) (*AddStorageResponse, error)
+	Status(context.Context, *StorageStatusRequest) (*StorageStatusResponse, error)
+}
+
+func RegisterStorageTankServer(s *grpc.Server, srv StorageTankServer) {
+	s.RegisterService(&_StorageTank_serviceDesc, srv)
+}
+
+func _StorageTank_WithdrawStorage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(WithdrawStorageRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(StorageTankServer).WithdrawStorage(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/deltav.model.StorageTank/WithdrawStorage",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(StorageTankServer).WithdrawStorage(ctx, req.(*WithdrawStorageRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _StorageTank_AddStorage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AddStorageRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(StorageTankServer).AddStorage(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/deltav.model.StorageTank/AddStorage",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(StorageTankServer).AddStorage(ctx, req.(*AddStorageRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _StorageTank_Status_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(StorageStatusRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(StorageTankServer).Status(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/deltav.model.StorageTank/Status",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(StorageTankServer).Status(ctx, req.(*StorageStatusRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _StorageTank_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "deltav.model.StorageTank",
+	HandlerType: (*StorageTankServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "WithdrawStorage",
+			Handler:    _StorageTank_WithdrawStorage_Handler,
+		},
+		{
+			MethodName: "AddStorage",
+			Handler:    _StorageTank_AddStorage_Handler,
+		},
+		{
+			MethodName: "Status",
+			Handler:    _StorageTank_Status_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "storage.proto",
+}
diff --git a/go/deltav/model/gomodel/vessel.pb.go b/go/deltav/model/gomodel/vessel.pb.go
new file mode 100644
index 0000000..fb1318e
--- /dev/null
+++ b/go/deltav/model/gomodel/vessel.pb.go
@@ -0,0 +1,246 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: vessel.proto
+
+package deltav_model
+
+import (
+	fmt "fmt"
+	proto "github.com/golang/protobuf/proto"
+	math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type RadiationType int32
+
+const (
+	RadiationType_UNKNOWN_RADIATION_TYPE RadiationType = 0
+	RadiationType_RF                     RadiationType = 1
+	RadiationType_GAMMA                  RadiationType = 2
+	RadiationType_THERM                  RadiationType = 3
+)
+
+var RadiationType_name = map[int32]string{
+	0: "UNKNOWN_RADIATION_TYPE",
+	1: "RF",
+	2: "GAMMA",
+	3: "THERM",
+}
+
+var RadiationType_value = map[string]int32{
+	"UNKNOWN_RADIATION_TYPE": 0,
+	"RF":    1,
+	"GAMMA": 2,
+	"THERM": 3,
+}
+
+func (x RadiationType) String() string {
+	return proto.EnumName(RadiationType_name, int32(x))
+}
+
+func (RadiationType) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_e0c0e45ee319d513, []int{0}
+}
+
+type Sensor_Type int32
+
+const (
+	Sensor_UNKNOWN Sensor_Type = 0
+	Sensor_PASSIVE Sensor_Type = 1
+	Sensor_ACTIVE  Sensor_Type = 2
+)
+
+var Sensor_Type_name = map[int32]string{
+	0: "UNKNOWN",
+	1: "PASSIVE",
+	2: "ACTIVE",
+}
+
+var Sensor_Type_value = map[string]int32{
+	"UNKNOWN": 0,
+	"PASSIVE": 1,
+	"ACTIVE":  2,
+}
+
+func (x Sensor_Type) String() string {
+	return proto.EnumName(Sensor_Type_name, int32(x))
+}
+
+func (Sensor_Type) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_e0c0e45ee319d513, []int{0, 0}
+}
+
+type Sensor struct {
+	SensorType           Sensor_Type   `protobuf:"varint,1,opt,name=sensor_type,json=sensorType,proto3,enum=deltav.model.Sensor_Type" json:"sensor_type,omitempty"`
+	RadiationType        RadiationType `protobuf:"varint,2,opt,name=radiation_type,json=radiationType,proto3,enum=deltav.model.RadiationType" json:"radiation_type,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
+	XXX_unrecognized     []byte        `json:"-"`
+	XXX_sizecache        int32         `json:"-"`
+}
+
+func (m *Sensor) Reset()         { *m = Sensor{} }
+func (m *Sensor) String() string { return proto.CompactTextString(m) }
+func (*Sensor) ProtoMessage()    {}
+func (*Sensor) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e0c0e45ee319d513, []int{0}
+}
+
+func (m *Sensor) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Sensor.Unmarshal(m, b)
+}
+func (m *Sensor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Sensor.Marshal(b, m, deterministic)
+}
+func (m *Sensor) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Sensor.Merge(m, src)
+}
+func (m *Sensor) XXX_Size() int {
+	return xxx_messageInfo_Sensor.Size(m)
+}
+func (m *Sensor) XXX_DiscardUnknown() {
+	xxx_messageInfo_Sensor.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Sensor proto.InternalMessageInfo
+
+func (m *Sensor) GetSensorType() Sensor_Type {
+	if m != nil {
+		return m.SensorType
+	}
+	return Sensor_UNKNOWN
+}
+
+func (m *Sensor) GetRadiationType() RadiationType {
+	if m != nil {
+		return m.RadiationType
+	}
+	return RadiationType_UNKNOWN_RADIATION_TYPE
+}
+
+type SensorSystem struct {
+	Sensors              []*Sensor `protobuf:"bytes,1,rep,name=sensors,proto3" json:"sensors,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
+	XXX_unrecognized     []byte    `json:"-"`
+	XXX_sizecache        int32     `json:"-"`
+}
+
+func (m *SensorSystem) Reset()         { *m = SensorSystem{} }
+func (m *SensorSystem) String() string { return proto.CompactTextString(m) }
+func (*SensorSystem) ProtoMessage()    {}
+func (*SensorSystem) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e0c0e45ee319d513, []int{1}
+}
+
+func (m *SensorSystem) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_SensorSystem.Unmarshal(m, b)
+}
+func (m *SensorSystem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_SensorSystem.Marshal(b, m, deterministic)
+}
+func (m *SensorSystem) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SensorSystem.Merge(m, src)
+}
+func (m *SensorSystem) XXX_Size() int {
+	return xxx_messageInfo_SensorSystem.Size(m)
+}
+func (m *SensorSystem) XXX_DiscardUnknown() {
+	xxx_messageInfo_SensorSystem.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SensorSystem proto.InternalMessageInfo
+
+func (m *SensorSystem) GetSensors() []*Sensor {
+	if m != nil {
+		return m.Sensors
+	}
+	return nil
+}
+
+type Vessel struct {
+	Id                   string        `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+	Sensors              *SensorSystem `protobuf:"bytes,2,opt,name=sensors,proto3" json:"sensors,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
+	XXX_unrecognized     []byte        `json:"-"`
+	XXX_sizecache        int32         `json:"-"`
+}
+
+func (m *Vessel) Reset()         { *m = Vessel{} }
+func (m *Vessel) String() string { return proto.CompactTextString(m) }
+func (*Vessel) ProtoMessage()    {}
+func (*Vessel) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e0c0e45ee319d513, []int{2}
+}
+
+func (m *Vessel) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Vessel.Unmarshal(m, b)
+}
+func (m *Vessel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Vessel.Marshal(b, m, deterministic)
+}
+func (m *Vessel) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Vessel.Merge(m, src)
+}
+func (m *Vessel) XXX_Size() int {
+	return xxx_messageInfo_Vessel.Size(m)
+}
+func (m *Vessel) XXX_DiscardUnknown() {
+	xxx_messageInfo_Vessel.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Vessel proto.InternalMessageInfo
+
+func (m *Vessel) GetId() string {
+	if m != nil {
+		return m.Id
+	}
+	return ""
+}
+
+func (m *Vessel) GetSensors() *SensorSystem {
+	if m != nil {
+		return m.Sensors
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterEnum("deltav.model.RadiationType", RadiationType_name, RadiationType_value)
+	proto.RegisterEnum("deltav.model.Sensor_Type", Sensor_Type_name, Sensor_Type_value)
+	proto.RegisterType((*Sensor)(nil), "deltav.model.Sensor")
+	proto.RegisterType((*SensorSystem)(nil), "deltav.model.SensorSystem")
+	proto.RegisterType((*Vessel)(nil), "deltav.model.Vessel")
+}
+
+func init() { proto.RegisterFile("vessel.proto", fileDescriptor_e0c0e45ee319d513) }
+
+var fileDescriptor_e0c0e45ee319d513 = []byte{
+	// 295 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x91, 0x41, 0x4b, 0xc3, 0x30,
+	0x1c, 0xc5, 0x97, 0x4c, 0x3b, 0xf6, 0xef, 0x36, 0x42, 0x10, 0x99, 0xf3, 0x32, 0x7a, 0x1a, 0x22,
+	0x39, 0x4c, 0x4f, 0x1e, 0x84, 0xa8, 0x55, 0x8b, 0xb4, 0x1b, 0x69, 0x9d, 0x78, 0x2a, 0x95, 0xe6,
+	0x50, 0xe8, 0xd6, 0xd2, 0x94, 0x41, 0xbf, 0x98, 0x9f, 0x4f, 0x9a, 0x38, 0xdd, 0x60, 0xb7, 0xf7,
+	0x87, 0xf7, 0x7e, 0x7d, 0xaf, 0x81, 0xc1, 0x56, 0x2a, 0x25, 0x73, 0x56, 0x56, 0x45, 0x5d, 0xd0,
+	0x41, 0x2a, 0xf3, 0x3a, 0xd9, 0xb2, 0x75, 0x91, 0xca, 0xdc, 0xf9, 0x46, 0x60, 0x85, 0x72, 0xa3,
+	0x8a, 0x8a, 0xde, 0x81, 0xad, 0xb4, 0x8a, 0xeb, 0xa6, 0x94, 0x63, 0x34, 0x45, 0xb3, 0xd1, 0xfc,
+	0x82, 0xed, 0xdb, 0x99, 0xb1, 0xb2, 0xa8, 0x29, 0xa5, 0x00, 0xe3, 0x6e, 0x35, 0x7d, 0x80, 0x51,
+	0x95, 0xa4, 0x59, 0x52, 0x67, 0xc5, 0xc6, 0xc4, 0xb1, 0x8e, 0x5f, 0x1e, 0xc6, 0xc5, 0xce, 0xa3,
+	0x01, 0xc3, 0x6a, 0xff, 0x74, 0xae, 0xe1, 0x44, 0xb3, 0x6c, 0xe8, 0xbd, 0x07, 0x6f, 0xc1, 0xe2,
+	0x23, 0x20, 0x9d, 0xf6, 0x58, 0xf2, 0x30, 0xf4, 0x56, 0x2e, 0x41, 0x14, 0xc0, 0xe2, 0x8f, 0x51,
+	0xab, 0xb1, 0x73, 0x0f, 0x03, 0x53, 0x26, 0x6c, 0x54, 0x2d, 0xd7, 0x94, 0x41, 0xcf, 0xf4, 0x51,
+	0x63, 0x34, 0xed, 0xce, 0xec, 0xf9, 0xd9, 0xb1, 0xe6, 0x62, 0x67, 0x72, 0x02, 0xb0, 0x56, 0xfa,
+	0xb7, 0xd0, 0x11, 0xe0, 0x2c, 0xd5, 0x73, 0xfb, 0x02, 0x67, 0x29, 0xbd, 0xfd, 0x27, 0xb5, 0x23,
+	0xec, 0xf9, 0xe4, 0x18, 0xc9, 0x7c, 0xf6, 0x8f, 0x77, 0xe5, 0xc1, 0xf0, 0x60, 0x1d, 0x9d, 0xc0,
+	0xf9, 0xef, 0x8c, 0x58, 0xf0, 0x27, 0x8f, 0x47, 0xde, 0x22, 0x88, 0xa3, 0xcf, 0xa5, 0x4b, 0x3a,
+	0xd4, 0x02, 0x2c, 0x9e, 0x09, 0xa2, 0x7d, 0x38, 0x7d, 0xe1, 0xbe, 0xcf, 0x09, 0x6e, 0x65, 0xf4,
+	0xea, 0x0a, 0x9f, 0x74, 0xbf, 0x2c, 0xfd, 0x50, 0x37, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x04,
+	0xb8, 0x53, 0x54, 0xb8, 0x01, 0x00, 0x00,
+}
diff --git a/go/deltav/model/gomodel/worldmodel.pb.go b/go/deltav/model/gomodel/worldmodel.pb.go
new file mode 100644
index 0000000..3538631
--- /dev/null
+++ b/go/deltav/model/gomodel/worldmodel.pb.go
@@ -0,0 +1,813 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: worldmodel.proto
+
+package deltav_model
+
+import (
+	fmt "fmt"
+	proto "github.com/golang/protobuf/proto"
+	context "golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
+	math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type IdentificationProperty struct {
+	Transponder          string   `protobuf:"bytes,1,opt,name=transponder,proto3" json:"transponder,omitempty"`
+	InternalId           string   `protobuf:"bytes,2,opt,name=internal_id,json=internalId,proto3" json:"internal_id,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *IdentificationProperty) Reset()         { *m = IdentificationProperty{} }
+func (m *IdentificationProperty) String() string { return proto.CompactTextString(m) }
+func (*IdentificationProperty) ProtoMessage()    {}
+func (*IdentificationProperty) Descriptor() ([]byte, []int) {
+	return fileDescriptor_a139271552183648, []int{0}
+}
+
+func (m *IdentificationProperty) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_IdentificationProperty.Unmarshal(m, b)
+}
+func (m *IdentificationProperty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_IdentificationProperty.Marshal(b, m, deterministic)
+}
+func (m *IdentificationProperty) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_IdentificationProperty.Merge(m, src)
+}
+func (m *IdentificationProperty) XXX_Size() int {
+	return xxx_messageInfo_IdentificationProperty.Size(m)
+}
+func (m *IdentificationProperty) XXX_DiscardUnknown() {
+	xxx_messageInfo_IdentificationProperty.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_IdentificationProperty proto.InternalMessageInfo
+
+func (m *IdentificationProperty) GetTransponder() string {
+	if m != nil {
+		return m.Transponder
+	}
+	return ""
+}
+
+func (m *IdentificationProperty) GetInternalId() string {
+	if m != nil {
+		return m.InternalId
+	}
+	return ""
+}
+
+type RadiationProperty struct {
+	Type                 RadiationType `protobuf:"varint,1,opt,name=type,proto3,enum=deltav.model.RadiationType" json:"type,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
+	XXX_unrecognized     []byte        `json:"-"`
+	XXX_sizecache        int32         `json:"-"`
+}
+
+func (m *RadiationProperty) Reset()         { *m = RadiationProperty{} }
+func (m *RadiationProperty) String() string { return proto.CompactTextString(m) }
+func (*RadiationProperty) ProtoMessage()    {}
+func (*RadiationProperty) Descriptor() ([]byte, []int) {
+	return fileDescriptor_a139271552183648, []int{1}
+}
+
+func (m *RadiationProperty) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_RadiationProperty.Unmarshal(m, b)
+}
+func (m *RadiationProperty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_RadiationProperty.Marshal(b, m, deterministic)
+}
+func (m *RadiationProperty) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_RadiationProperty.Merge(m, src)
+}
+func (m *RadiationProperty) XXX_Size() int {
+	return xxx_messageInfo_RadiationProperty.Size(m)
+}
+func (m *RadiationProperty) XXX_DiscardUnknown() {
+	xxx_messageInfo_RadiationProperty.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_RadiationProperty proto.InternalMessageInfo
+
+func (m *RadiationProperty) GetType() RadiationType {
+	if m != nil {
+		return m.Type
+	}
+	return RadiationType_UNKNOWN_RADIATION_TYPE
+}
+
+type SensorProperty struct {
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *SensorProperty) Reset()         { *m = SensorProperty{} }
+func (m *SensorProperty) String() string { return proto.CompactTextString(m) }
+func (*SensorProperty) ProtoMessage()    {}
+func (*SensorProperty) Descriptor() ([]byte, []int) {
+	return fileDescriptor_a139271552183648, []int{2}
+}
+
+func (m *SensorProperty) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_SensorProperty.Unmarshal(m, b)
+}
+func (m *SensorProperty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_SensorProperty.Marshal(b, m, deterministic)
+}
+func (m *SensorProperty) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SensorProperty.Merge(m, src)
+}
+func (m *SensorProperty) XXX_Size() int {
+	return xxx_messageInfo_SensorProperty.Size(m)
+}
+func (m *SensorProperty) XXX_DiscardUnknown() {
+	xxx_messageInfo_SensorProperty.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SensorProperty proto.InternalMessageInfo
+
+type DetectableProperty struct {
+	// Types that are valid to be assigned to Property:
+	//	*DetectableProperty_Id
+	//	*DetectableProperty_Radiation
+	Property             isDetectableProperty_Property `protobuf_oneof:"property"`
+	Intensity            float32                       `protobuf:"fixed32,100,opt,name=intensity,proto3" json:"intensity,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
+	XXX_unrecognized     []byte                        `json:"-"`
+	XXX_sizecache        int32                         `json:"-"`
+}
+
+func (m *DetectableProperty) Reset()         { *m = DetectableProperty{} }
+func (m *DetectableProperty) String() string { return proto.CompactTextString(m) }
+func (*DetectableProperty) ProtoMessage()    {}
+func (*DetectableProperty) Descriptor() ([]byte, []int) {
+	return fileDescriptor_a139271552183648, []int{3}
+}
+
+func (m *DetectableProperty) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_DetectableProperty.Unmarshal(m, b)
+}
+func (m *DetectableProperty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_DetectableProperty.Marshal(b, m, deterministic)
+}
+func (m *DetectableProperty) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DetectableProperty.Merge(m, src)
+}
+func (m *DetectableProperty) XXX_Size() int {
+	return xxx_messageInfo_DetectableProperty.Size(m)
+}
+func (m *DetectableProperty) XXX_DiscardUnknown() {
+	xxx_messageInfo_DetectableProperty.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DetectableProperty proto.InternalMessageInfo
+
+type isDetectableProperty_Property interface {
+	isDetectableProperty_Property()
+}
+
+type DetectableProperty_Id struct {
+	Id *IdentificationProperty `protobuf:"bytes,1,opt,name=id,proto3,oneof"`
+}
+
+type DetectableProperty_Radiation struct {
+	Radiation *RadiationProperty `protobuf:"bytes,2,opt,name=radiation,proto3,oneof"`
+}
+
+func (*DetectableProperty_Id) isDetectableProperty_Property() {}
+
+func (*DetectableProperty_Radiation) isDetectableProperty_Property() {}
+
+func (m *DetectableProperty) GetProperty() isDetectableProperty_Property {
+	if m != nil {
+		return m.Property
+	}
+	return nil
+}
+
+func (m *DetectableProperty) GetId() *IdentificationProperty {
+	if x, ok := m.GetProperty().(*DetectableProperty_Id); ok {
+		return x.Id
+	}
+	return nil
+}
+
+func (m *DetectableProperty) GetRadiation() *RadiationProperty {
+	if x, ok := m.GetProperty().(*DetectableProperty_Radiation); ok {
+		return x.Radiation
+	}
+	return nil
+}
+
+func (m *DetectableProperty) GetIntensity() float32 {
+	if m != nil {
+		return m.Intensity
+	}
+	return 0
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*DetectableProperty) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _DetectableProperty_OneofMarshaler, _DetectableProperty_OneofUnmarshaler, _DetectableProperty_OneofSizer, []interface{}{
+		(*DetectableProperty_Id)(nil),
+		(*DetectableProperty_Radiation)(nil),
+	}
+}
+
+func _DetectableProperty_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*DetectableProperty)
+	// property
+	switch x := m.Property.(type) {
+	case *DetectableProperty_Id:
+		b.EncodeVarint(1<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.Id); err != nil {
+			return err
+		}
+	case *DetectableProperty_Radiation:
+		b.EncodeVarint(2<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.Radiation); err != nil {
+			return err
+		}
+	case nil:
+	default:
+		return fmt.Errorf("DetectableProperty.Property has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _DetectableProperty_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*DetectableProperty)
+	switch tag {
+	case 1: // property.id
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(IdentificationProperty)
+		err := b.DecodeMessage(msg)
+		m.Property = &DetectableProperty_Id{msg}
+		return true, err
+	case 2: // property.radiation
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(RadiationProperty)
+		err := b.DecodeMessage(msg)
+		m.Property = &DetectableProperty_Radiation{msg}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _DetectableProperty_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*DetectableProperty)
+	// property
+	switch x := m.Property.(type) {
+	case *DetectableProperty_Id:
+		s := proto.Size(x.Id)
+		n += 1 // tag and wire
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *DetectableProperty_Radiation:
+		s := proto.Size(x.Radiation)
+		n += 1 // tag and wire
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
+type RegisterRequest struct {
+	Id                   string                `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+	Position             *Position             `protobuf:"bytes,2,opt,name=position,proto3" json:"position,omitempty"`
+	Properties           []*DetectableProperty `protobuf:"bytes,3,rep,name=properties,proto3" json:"properties,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
+	XXX_unrecognized     []byte                `json:"-"`
+	XXX_sizecache        int32                 `json:"-"`
+}
+
+func (m *RegisterRequest) Reset()         { *m = RegisterRequest{} }
+func (m *RegisterRequest) String() string { return proto.CompactTextString(m) }
+func (*RegisterRequest) ProtoMessage()    {}
+func (*RegisterRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_a139271552183648, []int{4}
+}
+
+func (m *RegisterRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_RegisterRequest.Unmarshal(m, b)
+}
+func (m *RegisterRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_RegisterRequest.Marshal(b, m, deterministic)
+}
+func (m *RegisterRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_RegisterRequest.Merge(m, src)
+}
+func (m *RegisterRequest) XXX_Size() int {
+	return xxx_messageInfo_RegisterRequest.Size(m)
+}
+func (m *RegisterRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_RegisterRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_RegisterRequest proto.InternalMessageInfo
+
+func (m *RegisterRequest) GetId() string {
+	if m != nil {
+		return m.Id
+	}
+	return ""
+}
+
+func (m *RegisterRequest) GetPosition() *Position {
+	if m != nil {
+		return m.Position
+	}
+	return nil
+}
+
+func (m *RegisterRequest) GetProperties() []*DetectableProperty {
+	if m != nil {
+		return m.Properties
+	}
+	return nil
+}
+
+type RegisterResponse struct {
+	Effect               string   `protobuf:"bytes,1,opt,name=effect,proto3" json:"effect,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *RegisterResponse) Reset()         { *m = RegisterResponse{} }
+func (m *RegisterResponse) String() string { return proto.CompactTextString(m) }
+func (*RegisterResponse) ProtoMessage()    {}
+func (*RegisterResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_a139271552183648, []int{5}
+}
+
+func (m *RegisterResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_RegisterResponse.Unmarshal(m, b)
+}
+func (m *RegisterResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_RegisterResponse.Marshal(b, m, deterministic)
+}
+func (m *RegisterResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_RegisterResponse.Merge(m, src)
+}
+func (m *RegisterResponse) XXX_Size() int {
+	return xxx_messageInfo_RegisterResponse.Size(m)
+}
+func (m *RegisterResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_RegisterResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_RegisterResponse proto.InternalMessageInfo
+
+func (m *RegisterResponse) GetEffect() string {
+	if m != nil {
+		return m.Effect
+	}
+	return ""
+}
+
+type DetectRequest struct {
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *DetectRequest) Reset()         { *m = DetectRequest{} }
+func (m *DetectRequest) String() string { return proto.CompactTextString(m) }
+func (*DetectRequest) ProtoMessage()    {}
+func (*DetectRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_a139271552183648, []int{6}
+}
+
+func (m *DetectRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_DetectRequest.Unmarshal(m, b)
+}
+func (m *DetectRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_DetectRequest.Marshal(b, m, deterministic)
+}
+func (m *DetectRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DetectRequest.Merge(m, src)
+}
+func (m *DetectRequest) XXX_Size() int {
+	return xxx_messageInfo_DetectRequest.Size(m)
+}
+func (m *DetectRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_DetectRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DetectRequest proto.InternalMessageInfo
+
+type DetectResponse struct {
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *DetectResponse) Reset()         { *m = DetectResponse{} }
+func (m *DetectResponse) String() string { return proto.CompactTextString(m) }
+func (*DetectResponse) ProtoMessage()    {}
+func (*DetectResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_a139271552183648, []int{7}
+}
+
+func (m *DetectResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_DetectResponse.Unmarshal(m, b)
+}
+func (m *DetectResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_DetectResponse.Marshal(b, m, deterministic)
+}
+func (m *DetectResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DetectResponse.Merge(m, src)
+}
+func (m *DetectResponse) XXX_Size() int {
+	return xxx_messageInfo_DetectResponse.Size(m)
+}
+func (m *DetectResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_DetectResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DetectResponse proto.InternalMessageInfo
+
+type GetRequest struct {
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetRequest) Reset()         { *m = GetRequest{} }
+func (m *GetRequest) String() string { return proto.CompactTextString(m) }
+func (*GetRequest) ProtoMessage()    {}
+func (*GetRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_a139271552183648, []int{8}
+}
+
+func (m *GetRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_GetRequest.Unmarshal(m, b)
+}
+func (m *GetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_GetRequest.Marshal(b, m, deterministic)
+}
+func (m *GetRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GetRequest.Merge(m, src)
+}
+func (m *GetRequest) XXX_Size() int {
+	return xxx_messageInfo_GetRequest.Size(m)
+}
+func (m *GetRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_GetRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetRequest proto.InternalMessageInfo
+
+type GetResponse struct {
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *GetResponse) Reset()         { *m = GetResponse{} }
+func (m *GetResponse) String() string { return proto.CompactTextString(m) }
+func (*GetResponse) ProtoMessage()    {}
+func (*GetResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_a139271552183648, []int{9}
+}
+
+func (m *GetResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_GetResponse.Unmarshal(m, b)
+}
+func (m *GetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_GetResponse.Marshal(b, m, deterministic)
+}
+func (m *GetResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GetResponse.Merge(m, src)
+}
+func (m *GetResponse) XXX_Size() int {
+	return xxx_messageInfo_GetResponse.Size(m)
+}
+func (m *GetResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_GetResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetResponse proto.InternalMessageInfo
+
+type InitializeRequest struct {
+	Vessel               *Vessel  `protobuf:"bytes,1,opt,name=vessel,proto3" json:"vessel,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *InitializeRequest) Reset()         { *m = InitializeRequest{} }
+func (m *InitializeRequest) String() string { return proto.CompactTextString(m) }
+func (*InitializeRequest) ProtoMessage()    {}
+func (*InitializeRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_a139271552183648, []int{10}
+}
+
+func (m *InitializeRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_InitializeRequest.Unmarshal(m, b)
+}
+func (m *InitializeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_InitializeRequest.Marshal(b, m, deterministic)
+}
+func (m *InitializeRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_InitializeRequest.Merge(m, src)
+}
+func (m *InitializeRequest) XXX_Size() int {
+	return xxx_messageInfo_InitializeRequest.Size(m)
+}
+func (m *InitializeRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_InitializeRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_InitializeRequest proto.InternalMessageInfo
+
+func (m *InitializeRequest) GetVessel() *Vessel {
+	if m != nil {
+		return m.Vessel
+	}
+	return nil
+}
+
+type InitializeResponse struct {
+	Vessel               *Vessel  `protobuf:"bytes,1,opt,name=vessel,proto3" json:"vessel,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *InitializeResponse) Reset()         { *m = InitializeResponse{} }
+func (m *InitializeResponse) String() string { return proto.CompactTextString(m) }
+func (*InitializeResponse) ProtoMessage()    {}
+func (*InitializeResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_a139271552183648, []int{11}
+}
+
+func (m *InitializeResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_InitializeResponse.Unmarshal(m, b)
+}
+func (m *InitializeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_InitializeResponse.Marshal(b, m, deterministic)
+}
+func (m *InitializeResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_InitializeResponse.Merge(m, src)
+}
+func (m *InitializeResponse) XXX_Size() int {
+	return xxx_messageInfo_InitializeResponse.Size(m)
+}
+func (m *InitializeResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_InitializeResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_InitializeResponse proto.InternalMessageInfo
+
+func (m *InitializeResponse) GetVessel() *Vessel {
+	if m != nil {
+		return m.Vessel
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*IdentificationProperty)(nil), "deltav.model.IdentificationProperty")
+	proto.RegisterType((*RadiationProperty)(nil), "deltav.model.RadiationProperty")
+	proto.RegisterType((*SensorProperty)(nil), "deltav.model.SensorProperty")
+	proto.RegisterType((*DetectableProperty)(nil), "deltav.model.DetectableProperty")
+	proto.RegisterType((*RegisterRequest)(nil), "deltav.model.RegisterRequest")
+	proto.RegisterType((*RegisterResponse)(nil), "deltav.model.RegisterResponse")
+	proto.RegisterType((*DetectRequest)(nil), "deltav.model.DetectRequest")
+	proto.RegisterType((*DetectResponse)(nil), "deltav.model.DetectResponse")
+	proto.RegisterType((*GetRequest)(nil), "deltav.model.GetRequest")
+	proto.RegisterType((*GetResponse)(nil), "deltav.model.GetResponse")
+	proto.RegisterType((*InitializeRequest)(nil), "deltav.model.InitializeRequest")
+	proto.RegisterType((*InitializeResponse)(nil), "deltav.model.InitializeResponse")
+}
+
+func init() { proto.RegisterFile("worldmodel.proto", fileDescriptor_a139271552183648) }
+
+var fileDescriptor_a139271552183648 = []byte{
+	// 494 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0x5d, 0x6f, 0xd3, 0x30,
+	0x14, 0x5d, 0x53, 0x54, 0xb5, 0x37, 0x5d, 0xd7, 0x59, 0xa8, 0x0a, 0xd9, 0x60, 0x51, 0xc4, 0x43,
+	0x85, 0x50, 0x91, 0x82, 0xc4, 0x13, 0x12, 0x30, 0x0d, 0x8d, 0x0a, 0x21, 0x0d, 0x83, 0xe0, 0x81,
+	0x07, 0x94, 0xd5, 0xb7, 0xc8, 0x52, 0x88, 0x83, 0x6d, 0x86, 0xca, 0x1f, 0xe1, 0x77, 0xf0, 0xc4,
+	0xdf, 0x43, 0x71, 0xec, 0x7c, 0x6c, 0xed, 0xc3, 0x1e, 0x7d, 0xcf, 0xb9, 0xc7, 0xe7, 0xde, 0xe3,
+	0x04, 0xa6, 0xbf, 0x84, 0xcc, 0xd8, 0x77, 0xc1, 0x30, 0x5b, 0x14, 0x52, 0x68, 0x41, 0xc6, 0x0c,
+	0x33, 0x9d, 0x5e, 0x2d, 0x4c, 0x2d, 0x9c, 0x14, 0x42, 0x71, 0xcd, 0x45, 0x5e, 0xa1, 0xe1, 0xf8,
+	0x0a, 0x95, 0x72, 0xdc, 0xf8, 0x0b, 0xcc, 0x96, 0x0c, 0x73, 0xcd, 0xd7, 0x7c, 0x95, 0x96, 0xac,
+	0x0b, 0x29, 0x0a, 0x94, 0x7a, 0x43, 0x22, 0xf0, 0xb5, 0x4c, 0x73, 0x55, 0x88, 0x9c, 0xa1, 0x0c,
+	0x7a, 0x51, 0x6f, 0x3e, 0xa2, 0xed, 0x12, 0x39, 0x01, 0x9f, 0xe7, 0x1a, 0x65, 0x9e, 0x66, 0x5f,
+	0x39, 0x0b, 0x3c, 0xc3, 0x00, 0x57, 0x5a, 0xb2, 0xf8, 0x0c, 0x0e, 0x69, 0xca, 0x78, 0x57, 0xf7,
+	0x09, 0xdc, 0xd1, 0x9b, 0x02, 0x8d, 0xe0, 0x24, 0x39, 0x5a, 0xb4, 0xcd, 0x2e, 0x6a, 0xfa, 0xc7,
+	0x4d, 0x81, 0xd4, 0x10, 0xe3, 0x29, 0x4c, 0x3e, 0x60, 0xae, 0x84, 0x74, 0x12, 0xf1, 0xbf, 0x1e,
+	0x90, 0x33, 0xd4, 0xb8, 0xd2, 0xe9, 0x65, 0x86, 0xb5, 0xf2, 0x33, 0xf0, 0x38, 0x33, 0xba, 0x7e,
+	0xf2, 0xb0, 0xab, 0xbb, 0x7d, 0xc6, 0x37, 0x7b, 0xd4, 0xe3, 0x8c, 0xbc, 0x80, 0x91, 0x74, 0xf7,
+	0x9a, 0x29, 0xfc, 0xe4, 0x64, 0x87, 0xad, 0x56, 0x67, 0xd3, 0x43, 0x8e, 0x61, 0x54, 0x4e, 0x9d,
+	0x2b, 0xae, 0x37, 0x01, 0x8b, 0x7a, 0x73, 0x8f, 0x36, 0x85, 0x53, 0x80, 0x61, 0xe1, 0x9c, 0xff,
+	0xe9, 0xc1, 0x01, 0xc5, 0x6f, 0x5c, 0x69, 0x94, 0x14, 0x7f, 0xfc, 0x44, 0xa5, 0xc9, 0xa4, 0xb6,
+	0x3d, 0x32, 0x76, 0x12, 0x18, 0xba, 0xc8, 0xac, 0x9b, 0x59, 0xd7, 0xcd, 0x85, 0x45, 0x69, 0xcd,
+	0x23, 0x2f, 0x01, 0xec, 0x1d, 0x1c, 0x55, 0xd0, 0x8f, 0xfa, 0x73, 0x3f, 0x89, 0xba, 0x5d, 0x37,
+	0x17, 0x46, 0x5b, 0x3d, 0xf1, 0x23, 0x98, 0x36, 0xc6, 0xca, 0x84, 0x15, 0x92, 0x19, 0x0c, 0x70,
+	0xbd, 0xc6, 0x95, 0xb6, 0xee, 0xec, 0x29, 0x3e, 0x80, 0xfd, 0x4a, 0xcd, 0x8e, 0x50, 0x46, 0xe4,
+	0x0a, 0x55, 0x6b, 0x3c, 0x06, 0x38, 0xc7, 0x1a, 0xdf, 0x07, 0xdf, 0x9c, 0x2c, 0xf8, 0x0a, 0x0e,
+	0x97, 0x39, 0xd7, 0x3c, 0xcd, 0xf8, 0x6f, 0x74, 0x6b, 0x78, 0x0c, 0x83, 0xea, 0x65, 0xda, 0x04,
+	0xef, 0x76, 0xed, 0x7f, 0x32, 0x18, 0xb5, 0x9c, 0xf8, 0x14, 0x48, 0x5b, 0xc2, 0x1a, 0xbe, 0x95,
+	0x46, 0xf2, 0xd7, 0x03, 0xf8, 0x5c, 0x7e, 0x3c, 0xef, 0x4a, 0x94, 0xbc, 0x85, 0xa1, 0xdb, 0x00,
+	0xb9, 0x7f, 0x2d, 0xff, 0x6e, 0x64, 0xe1, 0x83, 0x5d, 0xb0, 0x1d, 0x70, 0x8f, 0xbc, 0x86, 0x41,
+	0xb5, 0x11, 0x72, 0xb4, 0x2d, 0x06, 0x27, 0x74, 0xbc, 0x1d, 0xac, 0x65, 0x9e, 0x43, 0xff, 0x1c,
+	0x35, 0x09, 0xba, 0xb4, 0x66, 0xb3, 0xe1, 0xbd, 0x2d, 0x48, 0xdd, 0xfd, 0x1e, 0xa0, 0x59, 0x12,
+	0xb9, 0xf6, 0xa6, 0x6f, 0x24, 0x10, 0x46, 0xbb, 0x09, 0x4e, 0xf2, 0x72, 0x60, 0x7e, 0x1b, 0x4f,
+	0xff, 0x07, 0x00, 0x00, 0xff, 0xff, 0x43, 0x67, 0x09, 0xb6, 0x76, 0x04, 0x00, 0x00,
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// WorldModelClient is the client API for WorldModel service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
+type WorldModelClient interface {
+	Register(ctx context.Context, in *RegisterRequest, opts ...grpc.CallOption) (*RegisterResponse, error)
+	Detect(ctx context.Context, in *DetectRequest, opts ...grpc.CallOption) (*DetectResponse, error)
+	Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error)
+	Initialize(ctx context.Context, in *InitializeRequest, opts ...grpc.CallOption) (*InitializeResponse, error)
+}
+
+type worldModelClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewWorldModelClient(cc *grpc.ClientConn) WorldModelClient {
+	return &worldModelClient{cc}
+}
+
+func (c *worldModelClient) Register(ctx context.Context, in *RegisterRequest, opts ...grpc.CallOption) (*RegisterResponse, error) {
+	out := new(RegisterResponse)
+	err := c.cc.Invoke(ctx, "/deltav.model.WorldModel/Register", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *worldModelClient) Detect(ctx context.Context, in *DetectRequest, opts ...grpc.CallOption) (*DetectResponse, error) {
+	out := new(DetectResponse)
+	err := c.cc.Invoke(ctx, "/deltav.model.WorldModel/Detect", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *worldModelClient) Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error) {
+	out := new(GetResponse)
+	err := c.cc.Invoke(ctx, "/deltav.model.WorldModel/Get", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *worldModelClient) Initialize(ctx context.Context, in *InitializeRequest, opts ...grpc.CallOption) (*InitializeResponse, error) {
+	out := new(InitializeResponse)
+	err := c.cc.Invoke(ctx, "/deltav.model.WorldModel/Initialize", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// WorldModelServer is the server API for WorldModel service.
+type WorldModelServer interface {
+	Register(context.Context, *RegisterRequest) (*RegisterResponse, error)
+	Detect(context.Context, *DetectRequest) (*DetectResponse, error)
+	Get(context.Context, *GetRequest) (*GetResponse, error)
+	Initialize(context.Context, *InitializeRequest) (*InitializeResponse, error)
+}
+
+func RegisterWorldModelServer(s *grpc.Server, srv WorldModelServer) {
+	s.RegisterService(&_WorldModel_serviceDesc, srv)
+}
+
+func _WorldModel_Register_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(RegisterRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(WorldModelServer).Register(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/deltav.model.WorldModel/Register",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(WorldModelServer).Register(ctx, req.(*RegisterRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _WorldModel_Detect_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(DetectRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(WorldModelServer).Detect(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/deltav.model.WorldModel/Detect",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(WorldModelServer).Detect(ctx, req.(*DetectRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _WorldModel_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GetRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(WorldModelServer).Get(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/deltav.model.WorldModel/Get",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(WorldModelServer).Get(ctx, req.(*GetRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _WorldModel_Initialize_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(InitializeRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(WorldModelServer).Initialize(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/deltav.model.WorldModel/Initialize",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(WorldModelServer).Initialize(ctx, req.(*InitializeRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _WorldModel_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "deltav.model.WorldModel",
+	HandlerType: (*WorldModelServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "Register",
+			Handler:    _WorldModel_Register_Handler,
+		},
+		{
+			MethodName: "Detect",
+			Handler:    _WorldModel_Detect_Handler,
+		},
+		{
+			MethodName: "Get",
+			Handler:    _WorldModel_Get_Handler,
+		},
+		{
+			MethodName: "Initialize",
+			Handler:    _WorldModel_Initialize_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "worldmodel.proto",
+}
diff --git a/go/deltav/model/mass_object.proto b/go/deltav/model/mass_object.proto
new file mode 100644
index 0000000..0bf2c09
--- /dev/null
+++ b/go/deltav/model/mass_object.proto
@@ -0,0 +1,13 @@
+syntax = "proto3";
+
+package deltav.model;
+
+message GetMassRequest{}
+
+message GetMassResponse{
+    int64 kg = 1;
+}
+
+service MassObject {
+    rpc GetMass(GetMassRequest) returns (GetMassResponse) {}
+}   
\ No newline at end of file
diff --git a/go/deltav/model/position.proto b/go/deltav/model/position.proto
new file mode 100644
index 0000000..d8a7e53
--- /dev/null
+++ b/go/deltav/model/position.proto
@@ -0,0 +1,19 @@
+syntax = "proto3";
+
+package deltav.model;
+
+
+// Vector3 is a 3D vector. Double is used as compared to float
+// despite being 30% slower because the Math library uses Doubles.
+message Vector3 {
+    double X = 1;
+    double Y = 2;
+    double Z = 3;
+}
+
+
+// Position is a Vector3 spacial position combined with time.
+message Position {
+    Vector3 position = 1;
+    int64 T = 2;
+}
diff --git a/go/deltav/model/reactor.proto b/go/deltav/model/reactor.proto
new file mode 100644
index 0000000..0cd4354
--- /dev/null
+++ b/go/deltav/model/reactor.proto
@@ -0,0 +1,26 @@
+syntax = "proto3";
+
+package deltav.model;
+
+message ReactRequest {
+    double desiredEnergyTeraJoules = 1;
+}
+
+message ReactorOutput {
+    enum Type {
+        UNKNOWN = 0;
+        ENERGY_TJOULES = 1; // TerraJoules
+        HEAT_TJOULES = 2; // TerraJoules
+        GAMMA_TJOULES = 3; // TerraJoules
+    }
+    Type type = 1;
+    double amount = 2; 
+}
+
+message ReactResponse {
+    repeated ReactorOutput outputs = 1;
+}
+
+service Reactor {
+    rpc React(ReactRequest) returns (ReactResponse) {}
+}   
\ No newline at end of file
diff --git a/go/deltav/model/storage.proto b/go/deltav/model/storage.proto
new file mode 100644
index 0000000..146e626
--- /dev/null
+++ b/go/deltav/model/storage.proto
@@ -0,0 +1,50 @@
+syntax = "proto3";
+
+package deltav.model;
+
+enum StorageType {
+    UNKNOWN_STORAGE_TYPE = 0;
+    HELIUM3_KG = 1;
+    DEUTERIUM_KG = 2;
+    WATER_KG = 3;
+    ELECTRIC_JOULES = 4;
+    HEAT_JOULES = 5;
+}
+
+message Storage {
+    double amount = 1;
+    StorageType type = 2;
+}
+
+message AddStorageRequest {
+    Storage storage = 1;
+}
+
+message AddStorageResponse {
+    Storage storage = 1;
+    string err = 2;
+}
+
+message WithdrawStorageRequest {
+    Storage storage = 1;
+}
+
+message WithdrawStorageResponse {
+    Storage storage = 1;
+    string err = 2;
+}
+
+message StorageStatusRequest{}
+
+message StorageStatusResponse {
+    double capacity = 1;
+    double current = 2;
+    StorageType type = 3;
+}
+
+
+service StorageTank {
+    rpc WithdrawStorage(WithdrawStorageRequest) returns (WithdrawStorageResponse) {}
+    rpc AddStorage(AddStorageRequest) returns (AddStorageResponse) {}
+    rpc Status(StorageStatusRequest) returns (StorageStatusResponse) {}
+}   
\ No newline at end of file
diff --git a/go/deltav/model/vessel.proto b/go/deltav/model/vessel.proto
new file mode 100644
index 0000000..780818c
--- /dev/null
+++ b/go/deltav/model/vessel.proto
@@ -0,0 +1,36 @@
+syntax = "proto3";
+
+package deltav.model;
+
+enum RadiationType {
+    UNKNOWN_RADIATION_TYPE = 0;
+    RF = 1;
+    GAMMA = 2;
+    THERM = 3;
+}
+
+message Sensor {
+    enum Type {
+        UNKNOWN = 0;
+        PASSIVE = 1;
+        ACTIVE = 2;
+    }
+    Type sensor_type = 1;
+    RadiationType radiation_type = 2;
+    // float mass = 3;
+    // float power_draw = 4;
+}
+
+message SensorSystem {
+    repeated Sensor sensors = 1;
+    // float idle_power = 2;
+    // float base_mass = 3;
+}
+
+message Vessel {
+    string id = 1;
+    SensorSystem sensors = 2;
+    // Driver driver = 3;
+    // WeaponSystem weapons = 4;
+    // float chassis_mass = 5; // Replace with a database lookup.
+}
diff --git a/go/deltav/model/worldmodel.proto b/go/deltav/model/worldmodel.proto
new file mode 100644
index 0000000..3c7b20a
--- /dev/null
+++ b/go/deltav/model/worldmodel.proto
@@ -0,0 +1,67 @@
+syntax = "proto3";
+
+package deltav.model;
+
+import "position.proto";
+import "vessel.proto";
+
+message IdentificationProperty {
+    string transponder = 1;
+    string internal_id = 2;
+}
+
+message RadiationProperty {
+    RadiationType type = 1;
+}
+
+message SensorProperty {
+
+}
+
+message DetectableProperty{
+    oneof property{
+        IdentificationProperty id = 1;
+        RadiationProperty radiation = 2;
+    }
+    float intensity = 100; // Range this property is detectable.
+}
+
+message RegisterRequest {
+    string id = 1;  // Unique id for the object.
+    Position position = 2;
+    repeated DetectableProperty properties = 3;
+}
+
+message RegisterResponse {
+    string effect = 1;
+}
+
+message DetectRequest {
+}
+
+message DetectResponse{
+}
+
+
+message GetRequest {
+}
+
+message GetResponse{
+}
+
+message InitializeRequest {
+    Vessel vessel = 1;
+}
+
+message InitializeResponse {
+    Vessel vessel = 1; // Sends back the initialized vessel.
+}
+
+service WorldModel
+ {
+    rpc Register(RegisterRequest) returns (RegisterResponse) {}
+    rpc Detect(DetectRequest) returns (DetectResponse) {}
+    rpc Get(GetRequest) returns (GetResponse) {}
+    rpc Initialize(InitializeRequest) returns (InitializeResponse) {}
+ }
+
diff --git a/go/deltav/objects/reactor/mock_reactor.go b/go/deltav/objects/reactor/mock_reactor.go
new file mode 100644
index 0000000..0a31594
--- /dev/null
+++ b/go/deltav/objects/reactor/mock_reactor.go
@@ -0,0 +1,23 @@
+package reactor
+
+import (
+	"context"
+
+	model "github.com/golang001/deltav/model/gomodel"
+	"github.com/golang001/deltav/utils"
+)
+
+// MockReactor returns a rote ReactResponse or error. Used for testing.
+type MockReactor struct {
+	response model.ReactResponse
+	err      error
+}
+
+// React implaments the GRPC interface for a Reactor.
+func (mr *MockReactor) React(ctx context.Context, req *model.ReactRequest) (res *model.ReactResponse,
+	err error) {
+	defer utils.CapturePanic(ctx, res, &err)
+	*res = mr.response
+	err = mr.err
+	return
+}
diff --git a/go/deltav/objects/reactor/reactor.go b/go/deltav/objects/reactor/reactor.go
new file mode 100644
index 0000000..8b5d6ef
--- /dev/null
+++ b/go/deltav/objects/reactor/reactor.go
@@ -0,0 +1,89 @@
+package reactor
+
+import (
+	"context"
+	"math"
+
+	model "github.com/golang001/deltav/model/gomodel"
+	"github.com/golang001/deltav/utils"
+)
+
+// FusionReactor is a reactor that implaments the GRPC Reactor interface.
+/*
+It works by reacting helium and deuterium and produces heat, energy.
+TODO: For future realism, it should produce a small amount of gamma radiation
+and should slowly degrade over time due to neutron bombardment because a
+small number of deuterium-deuterium reactions should occur.
+*/
+type FusionReactor struct {
+	heliumBuffer    model.StorageTankClient
+	deuteriumBuffer model.StorageTankClient
+	maxEfficency    float64 // Should never be above 0.7
+}
+
+const (
+	// http://www.asi.org/adb/02/09/he3-intro.html
+	tJPerKgH3                  float64 = 2157000
+	tJPerKgDeut                float64 = tJPerKgH3 / 0.66
+	inverseTeraJoulesPerKgH3           = 1 / tJPerKgH3
+	inverseTeraJoulesPerKgDeut         = 1 / tJPerKgDeut
+)
+
+// React implaments the GRPC interface for a Reactor.
+func (mr *FusionReactor) React(ctx context.Context, req *model.ReactRequest) (res *model.ReactResponse,
+	err error) {
+	defer utils.CapturePanic(ctx, res, &err)
+
+	// To get the desired energy, we need to increase the reaction mass in proportion to the efficency of the reaction.
+	invMaxEfficency := 1 / mr.maxEfficency
+
+	getFuel := func(fuelTank model.StorageTankClient, desiredAmount float64) (float64, error) {
+		res, err := fuelTank.WithdrawStorage(ctx,
+			&model.WithdrawStorageRequest{Storage: &model.Storage{Amount: desiredAmount}},
+		)
+		if err != nil {
+			return 0, err
+		}
+		// We might get less back than anticipated.
+		fraction := res.Storage.Amount / desiredAmount // Expensive, consider inverse math.
+		if fraction > 0.99 {                           // Correct for floating point errors.
+			fraction = 1.0
+		}
+		return fraction, nil
+	}
+
+	h3Desired := req.DesiredEnergyTeraJoules * inverseTeraJoulesPerKgH3 * invMaxEfficency
+	h3Fraction, err := getFuel(mr.heliumBuffer, h3Desired)
+	if err != nil {
+		return
+	}
+
+	deutDesired := req.DesiredEnergyTeraJoules * inverseTeraJoulesPerKgDeut * invMaxEfficency
+	deutFraction, err := getFuel(mr.deuteriumBuffer, deutDesired)
+	if err != nil {
+		return
+	}
+
+	// We take the min energy fraction as the true fraction.
+	energyFraction := math.Min(h3Fraction, deutFraction)
+	energy := energyFraction * req.DesiredEnergyTeraJoules
+	heat := energy/mr.maxEfficency - energy // A fraction of the total output is heat.
+
+	res = &model.ReactResponse{
+		Outputs: []*model.ReactorOutput{
+			{Type: model.ReactorOutput_ENERGY_TJOULES, Amount: energy},
+			{Type: model.ReactorOutput_HEAT_TJOULES, Amount: heat},
+		},
+	}
+	err = nil
+
+	return
+}
+
+/*
+TODO:
+Options-
+ this reactor needs to be topped off (self-contained, harder to manage, needs to implemnt storage interface)
+ we can say fuck the buffer and it can request fuel from the main tanks directly (chaos dependencies, maybe a good thing)
+ or we can have a monolith service for the ship to make requests from (maybe doesn't scale)
+*/
diff --git a/go/deltav/objects/reactor/reactor_test.go b/go/deltav/objects/reactor/reactor_test.go
new file mode 100644
index 0000000..b2fa839
--- /dev/null
+++ b/go/deltav/objects/reactor/reactor_test.go
@@ -0,0 +1,59 @@
+package reactor
+
+import (
+	"context"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+
+	mock_gomodel "github.com/golang001/deltav/model/gomock"
+	models "github.com/golang001/deltav/model/gomodel"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestReactor(t *testing.T) {
+
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+
+	energyDesired := float64(2157000)
+	efficency := float64(0.5)
+
+	expectedH3Request := models.WithdrawStorageRequest{Storage: &models.Storage{Amount: float64(2.00)}}
+	expectedH3Response := models.WithdrawStorageResponse{
+		Storage: &models.Storage{
+			Amount: float64(2.00),
+			Type:   models.StorageType_HELIUM3_KG,
+		}}
+	h3Mock := mock_gomodel.NewMockStorageTankClient(mockCtrl)
+	h3Mock.EXPECT().WithdrawStorage(context.Background(),
+		&expectedH3Request).Return(&expectedH3Response, nil).Times(1)
+
+	expectedDeutRequest := models.WithdrawStorageRequest{Storage: &models.Storage{Amount: float64(1.32)}}
+	expectedDeutResponse := models.WithdrawStorageResponse{
+		Storage: &models.Storage{
+			Amount: float64(1.32),
+			Type:   models.StorageType_DEUTERIUM_KG,
+		}}
+	deutMock := mock_gomodel.NewMockStorageTankClient(mockCtrl)
+	deutMock.EXPECT().WithdrawStorage(context.Background(),
+		&expectedDeutRequest).Return(&expectedDeutResponse, nil).Times(1)
+
+	reactor := FusionReactor{heliumBuffer: h3Mock, deuteriumBuffer: deutMock, maxEfficency: efficency}
+
+	req := models.ReactRequest{DesiredEnergyTeraJoules: energyDesired}
+	res, err := reactor.React(context.Background(), &req)
+	assert.NoError(t, err)
+
+	expectedResponse := &models.ReactResponse{
+		Outputs: []*models.ReactorOutput{
+			{
+				Type:   models.ReactorOutput_ENERGY_TJOULES,
+				Amount: energyDesired},
+			{
+				Type:   models.ReactorOutput_HEAT_TJOULES,
+				Amount: energyDesired}, // With an efficency of 50%, half the enregy becomes heat.
+		},
+	}
+	assert.Equal(t, expectedResponse, res)
+}
diff --git a/go/deltav/objects/sensor/sensor.go b/go/deltav/objects/sensor/sensor.go
new file mode 100644
index 0000000..8b4386c
--- /dev/null
+++ b/go/deltav/objects/sensor/sensor.go
@@ -0,0 +1,4 @@
+package sensor
+
+type Sensor interface {
+}
diff --git a/go/deltav/objects/shuttle/main/main.go b/go/deltav/objects/shuttle/main/main.go
new file mode 100644
index 0000000..d761efa
--- /dev/null
+++ b/go/deltav/objects/shuttle/main/main.go
@@ -0,0 +1,46 @@
+package main
+
+import (
+	"context"
+	"log"
+
+	protos "github.com/golang001/deltav/model/gomodel"
+	"github.com/golang001/deltav/objects/shuttle"
+	"google.golang.org/grpc"
+)
+
+const (
+	address     = "localhost:50051"
+	defaultName = "world"
+)
+
+func main() {
+	// Set up a connection to the server.
+	conn, err := grpc.Dial(address, grpc.WithInsecure())
+	if err != nil {
+		log.Fatalf("did not connect: %v", err)
+	}
+	defer conn.Close()
+	c := protos.NewWorldModelClient(conn)
+
+	vessel := protos.Vessel{
+		Sensors: &protos.SensorSystem{
+			Sensors: []*protos.Sensor{
+				{
+					SensorType:    protos.Sensor_PASSIVE,
+					RadiationType: protos.RadiationType_GAMMA,
+				},
+			},
+		},
+	}
+	_, err = shuttle.NewPlayerShuttle(vessel, c)
+	if err != nil {
+		log.Fatalf("could not create user: %v", err)
+
+	}
+	r, err := c.Register(context.Background(), &protos.RegisterRequest{})
+	if err != nil {
+		log.Fatalf("could not register: %v", err)
+	}
+	log.Printf("Greeting: %s", r.Effect)
+}
diff --git a/go/deltav/objects/shuttle/shuttle.go b/go/deltav/objects/shuttle/shuttle.go
new file mode 100644
index 0000000..2a1e833
--- /dev/null
+++ b/go/deltav/objects/shuttle/shuttle.go
@@ -0,0 +1,37 @@
+package shuttle
+
+import (
+	"context"
+
+	protos "github.com/golang001/deltav/model/gomodel"
+)
+
+/*
+A shuttle is a front-end client that lives in a main process that is constantly
+communicating with other elements. LocalSensors live on the client process but
+remote sensors are network addresses. The network latency can be compensated for
+by subracting the latency from the injected latency.
+*/
+
+type PlayerShuttle struct {
+	vessel protos.Vessel
+
+	commandCenter protos.WorldModelClient
+}
+
+func NewPlayerShuttle(vessel protos.Vessel,
+	commandCenter protos.WorldModelClient) (*PlayerShuttle, error) {
+	ps := &PlayerShuttle{vessel: vessel, commandCenter: commandCenter}
+	err := ps.Initialize()
+	return ps, err
+}
+
+func (ps *PlayerShuttle) Initialize() error {
+	res, err := ps.commandCenter.Initialize(context.Background(),
+		&protos.InitializeRequest{Vessel: &ps.vessel})
+	if err != nil {
+		return err
+	}
+	ps.vessel = *res.Vessel
+	return nil
+}
diff --git a/go/deltav/objects/storage/genericTank.go b/go/deltav/objects/storage/genericTank.go
new file mode 100644
index 0000000..5625c91
--- /dev/null
+++ b/go/deltav/objects/storage/genericTank.go
@@ -0,0 +1,91 @@
+package storage
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"net"
+	"sync"
+	"time"
+
+	model "github.com/golang001/deltav/model/gomodel"
+	"github.com/golang001/deltav/utils"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/reflection"
+)
+
+type GenericTank struct {
+	capacity    float64
+	current     float64
+	storageType model.StorageType
+
+	mux sync.RWMutex
+}
+
+func startGasTank(gt *GenericTank, port int) {
+	lis, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
+	if err != nil {
+		log.Fatalf("failed to listen: %v", err)
+	}
+	serve := grpc.NewServer()
+	model.RegisterStorageTankServer(serve, gt)
+	// Register reflection service on gRPC server.
+	reflection.Register(serve)
+	if err := serve.Serve(lis); err != nil {
+		log.Fatalf("failed to serve: %v", err)
+	}
+}
+
+func getGasTankClient(port int) model.StorageTankClient {
+	conn, err := grpc.Dial(fmt.Sprintf("localhost:%d", port), grpc.WithInsecure())
+	if err != nil {
+		log.Fatalf("did not connect: %v", err)
+	}
+	defer conn.Close()
+	return model.NewStorageTankClient(conn)
+}
+
+func NewGasTank(capacity float64, initialVolume float64, storageType model.StorageType, port int) model.StorageTankClient {
+	go startGasTank(&GenericTank{capacity: capacity, current: initialVolume, storageType: storageType}, port)
+	time.Sleep(time.Second)
+
+	return getGasTankClient(port)
+}
+
+// WithdrawStorage implaments the GRPC interface for a Storage.
+func (gt *GenericTank) WithdrawStorage(ctx context.Context, req *model.WithdrawStorageRequest) (res *model.WithdrawStorageResponse,
+	err error) {
+	gt.mux.Lock()
+	defer gt.mux.Unlock()
+	defer utils.CapturePanic(ctx, res, &err)
+	if gt.current < req.Storage.Amount {
+		gt.current = 0
+		return &model.WithdrawStorageResponse{Storage: &model.Storage{Amount: gt.current, Type: gt.storageType}}, nil
+	}
+	gt.current -= req.Storage.Amount
+	return &model.WithdrawStorageResponse{Storage: &model.Storage{Amount: req.Storage.Amount, Type: gt.storageType}}, nil
+}
+
+// AddStorage implaments the GRPC interface for a Storage.
+func (gt *GenericTank) AddStorage(ctx context.Context, req *model.AddStorageRequest) (res *model.AddStorageResponse,
+	err error) {
+	gt.mux.Lock()
+	defer gt.mux.Unlock()
+	defer utils.CapturePanic(ctx, res, &err)
+	spareCap := gt.capacity - req.Storage.Amount + gt.current
+	if spareCap < 0 {
+		gt.current = gt.capacity
+		return &model.AddStorageResponse{Storage: &model.Storage{Amount: req.Storage.Amount + spareCap, Type: gt.storageType}}, nil
+	}
+	return &model.AddStorageResponse{Storage: &model.Storage{Amount: float64(0), Type: gt.storageType}}, nil
+}
+
+// Status implaments the GRPC interface for a Storage.
+func (gt *GenericTank) Status(ctx context.Context, req *model.StorageStatusRequest) (res *model.StorageStatusResponse,
+	err error) {
+	gt.mux.RLock()
+	defer gt.mux.RUnlock()
+	defer utils.CapturePanic(ctx, res, &err)
+
+	return &model.StorageStatusResponse{Capacity: gt.capacity, Current: gt.current, Type: gt.storageType}, nil
+}
diff --git a/go/deltav/objects/storage/mock_storage.go b/go/deltav/objects/storage/mock_storage.go
new file mode 100644
index 0000000..1e2dc96
--- /dev/null
+++ b/go/deltav/objects/storage/mock_storage.go
@@ -0,0 +1,33 @@
+package storage
+
+// import (
+// 	"context"
+
+// 	model "github.com/golang001/deltav/model/gomodel"
+// 	"github.com/golang001/deltav/utils"
+// )
+
+// // MockReactor returns a rote ReactResponse or error. Used for testing.
+// type MockStorage struct {
+// 	withdrawResp model.StorageResponse
+// 	addResp      model.StorageResponse
+// 	err          error
+// }
+
+// // WithdrawStorage implaments the GRPC interface for a Storage.
+// func (mr *MockStorage) WithdrawStorage(ctx context.Context, req *model.StorageRequest) (res *model.StorageResponse,
+// 	err error) {
+// 	defer utils.CapturePanic(ctx, res, &err)
+// 	*res = mr.withdrawResp
+// 	err = mr.err
+// 	return
+// }
+
+// // WithdrawStorage implaments the GRPC interface for a Storage.
+// func (mr *MockStorage) AddStorage(ctx context.Context, req *model.StorageRequest) (res *model.StorageResponse,
+// 	err error) {
+// 	defer utils.CapturePanic(ctx, res, &err)
+// 	*res = mr.addResp
+// 	err = mr.err
+// 	return
+// }
diff --git a/go/deltav/utils/capture_panics.go b/go/deltav/utils/capture_panics.go
new file mode 100644
index 0000000..af330ba
--- /dev/null
+++ b/go/deltav/utils/capture_panics.go
@@ -0,0 +1,15 @@
+package utils
+
+import (
+	"context"
+	"fmt"
+)
+
+// CapturePanic should be deferred and will capture any panics in the foreground process.
+func CapturePanic(ctx context.Context, res interface{}, err *error) {
+	r := recover()
+	if r != nil {
+		res = nil
+		*err = fmt.Errorf("encountered a panic: %+v", r)
+	}
+}
diff --git a/python/__init__.py b/python/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/python/main.py b/python/main.py
new file mode 100644
index 0000000..3aa91ef
--- /dev/null
+++ b/python/main.py
@@ -0,0 +1,4 @@
+
+
+def main():
+  print("starting")
\ No newline at end of file
diff --git a/python/vector.py b/python/vector.py
new file mode 100644
index 0000000..9c10cf5
--- /dev/null
+++ b/python/vector.py
@@ -0,0 +1,11 @@
+class Vector:
+    x = 0
+    y = 0
+    z = 0
+    t = 0
+
+    def __init__(self, x, y, z, t):
+        self.x = x
+        self.y = y
+        self.z = z
+        self.t = t