diff --git a/lib/stats/map.go b/lib/stats/map.go
new file mode 100644
index 0000000..89312f6
--- /dev/null
+++ b/lib/stats/map.go
@@ -0,0 +1,165 @@
+package stats
+
+import (
+	"path"
+	"sort"
+	"sync"
+	"time"
+)
+
+// NewMap creates a new Map StatsObject with the given name and
+// returns a pointer to it.
+func NewMap(name string) *Map {
+	lock.Lock()
+	defer lock.Unlock()
+	node := findNodeLocked(name, true)
+	m := Map{name: name, value: make(map[string]mapValue)}
+	node.object = &m
+	return &m
+}
+
+// Map implements the StatsObject interface. The map keys are strings and the
+// values can be bool, int64, uint64, float64, or string.
+type Map struct {
+	mu    sync.RWMutex // ACQUIRED_BEFORE(stats.lock)
+	name  string
+	value map[string]mapValue // GUARDED_BY(mu)
+}
+
+type mapValue struct {
+	lastUpdate time.Time
+	value      interface{}
+}
+
+// Set sets the values of the given keys. There must be exactly one value for
+// each key.
+func (m *Map) Set(kvpairs []KeyValue) {
+	now := time.Now()
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	for _, kv := range kvpairs {
+		var v interface{}
+		switch value := kv.Value.(type) {
+		case bool:
+			v = bool(value)
+		case int:
+			v = int64(value)
+		case int8:
+			v = int64(value)
+		case int16:
+			v = int64(value)
+		case int32:
+			v = int64(value)
+		case int64:
+			v = int64(value)
+		case uint:
+			v = uint64(value)
+		case uint8:
+			v = uint64(value)
+		case uint16:
+			v = uint64(value)
+		case uint32:
+			v = uint64(value)
+		case uint64:
+			v = uint64(value)
+		case float32:
+			v = float64(value)
+		case float64:
+			v = float64(value)
+		case string:
+			v = string(value)
+		default:
+			panic("attempt to use an unsupported type as value")
+		}
+		m.value[kv.Key] = mapValue{now, v}
+	}
+	m.insertMissingNodes()
+}
+
+// Delete deletes the given keys from the map object.
+func (m *Map) Delete(keys []string) {
+	// The lock order is important.
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	lock.Lock()
+	defer lock.Unlock()
+	n := findNodeLocked(m.name, false)
+	for _, k := range keys {
+		delete(m.value, k)
+		if n != nil {
+			delete(n.children, k)
+		}
+	}
+}
+
+// Keys returns a sorted list of all the keys in the map.
+func (m *Map) Keys() []string {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	keys := []string{}
+	for k, _ := range m.value {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	return keys
+}
+
+// LastUpdate always returns a zero-value Time for a Map.
+func (m *Map) LastUpdate() time.Time {
+	return time.Time{}
+}
+
+// Value always returns nil for a Map.
+func (m *Map) Value() interface{} {
+	return nil
+}
+
+// insertMissingNodes inserts all the missing nodes.
+func (m *Map) insertMissingNodes() {
+	missing := []string{}
+	lock.RLock()
+	for key, _ := range m.value {
+		oName := path.Join(m.name, key)
+		if n := findNodeLocked(oName, false); n == nil {
+			missing = append(missing, key)
+		}
+	}
+	lock.RUnlock()
+	if len(missing) == 0 {
+		return
+	}
+
+	lock.Lock()
+	for _, key := range missing {
+		oName := path.Join(m.name, key)
+		if n := findNodeLocked(oName, true); n.object == nil {
+			n.object = &mapValueWrapper{m, key}
+		}
+	}
+	lock.Unlock()
+}
+
+type mapValueWrapper struct {
+	m   *Map
+	key string
+}
+
+// LastUpdate returns the time at which the parent map object was last updated.
+func (w *mapValueWrapper) LastUpdate() time.Time {
+	w.m.mu.RLock()
+	defer w.m.mu.RUnlock()
+	if v, ok := w.m.value[w.key]; ok {
+		return v.lastUpdate
+	}
+	return time.Time{}
+}
+
+// Value returns the current value for the map key.
+func (w *mapValueWrapper) Value() interface{} {
+	w.m.mu.RLock()
+	defer w.m.mu.RUnlock()
+	if v, ok := w.m.value[w.key]; ok {
+		return v.value
+	}
+	return nil
+}
diff --git a/lib/stats/stats.go b/lib/stats/stats.go
index e55947c..d06dabf 100644
--- a/lib/stats/stats.go
+++ b/lib/stats/stats.go
@@ -33,7 +33,7 @@
 
 var (
 	lock        sync.RWMutex
-	repository  *node
+	repository  *node // GUARDED_BY(lock)
 	ErrNotFound = errors.New("name not found")
 	ErrNoValue  = errors.New("object has no value")
 )
diff --git a/lib/stats/stats_test.go b/lib/stats/stats_test.go
index dc2c8c6..9a3f6b1 100644
--- a/lib/stats/stats_test.go
+++ b/lib/stats/stats_test.go
@@ -9,16 +9,13 @@
 	"veyron.io/veyron/veyron/lib/stats/counter"
 	"veyron.io/veyron/veyron/lib/stats/histogram"
 	istats "veyron.io/veyron/veyron/services/mgmt/stats"
-
-	"veyron.io/veyron/veyron2/rt"
 )
 
 func doGlob(root, pattern string, since time.Time, includeValues bool) ([]libstats.KeyValue, error) {
 	it := libstats.Glob(root, pattern, since, includeValues)
 	out := []libstats.KeyValue{}
 	for it.Advance() {
-		v := it.Value()
-		out = append(out, v)
+		out = append(out, it.Value())
 	}
 	if err := it.Err(); err != nil {
 		return nil, err
@@ -27,8 +24,6 @@
 }
 
 func TestStats(t *testing.T) {
-	rt.Init()
-
 	now := time.Unix(1, 0)
 	counter.Now = func() time.Time { return now }
 
@@ -273,6 +268,54 @@
 	}
 }
 
+func TestMap(t *testing.T) {
+	m := libstats.NewMap("testing/foo")
+	m.Set([]libstats.KeyValue{{"a", 1}, {"b", 2}})
+
+	// Test the Value of the map.
+	{
+		got, err := libstats.Value("testing/foo")
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+		}
+		if expected := interface{}(nil); got != expected {
+			t.Errorf("unexpected result. Got %v, want %v", got, expected)
+		}
+	}
+	// Test Glob on the map object.
+	{
+		got, err := doGlob("testing", "foo/...", time.Time{}, true)
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+		}
+		expected := []libstats.KeyValue{
+			libstats.KeyValue{Key: "foo", Value: nil},
+			libstats.KeyValue{Key: "foo/a", Value: int64(1)},
+			libstats.KeyValue{Key: "foo/b", Value: int64(2)},
+		}
+		if !reflect.DeepEqual(got, expected) {
+			t.Errorf("unexpected result. Got %#v, want %#v", got, expected)
+		}
+	}
+
+	m.Delete([]string{"a"})
+
+	// Test Glob on the map object.
+	{
+		got, err := doGlob("testing", "foo/...", time.Time{}, true)
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+		}
+		expected := []libstats.KeyValue{
+			libstats.KeyValue{Key: "foo", Value: nil},
+			libstats.KeyValue{Key: "foo/b", Value: int64(2)},
+		}
+		if !reflect.DeepEqual(got, expected) {
+			t.Errorf("unexpected result. Got %#v, want %#v", got, expected)
+		}
+	}
+}
+
 func TestDelete(t *testing.T) {
 	_ = libstats.NewInteger("a/b/c/d")
 	if _, err := libstats.GetStatsObject("a/b/c/d"); err != nil {
diff --git a/lib/stats/sysstats/sysstats.go b/lib/stats/sysstats/sysstats.go
new file mode 100644
index 0000000..ead2de1
--- /dev/null
+++ b/lib/stats/sysstats/sysstats.go
@@ -0,0 +1,73 @@
+// Package sysstats exports system statistics, and updates them periodically.
+// The package does not export any symbols, but needs to be imported for its
+// side-effects.
+package sysstats
+
+import (
+	"os"
+	"reflect"
+	"runtime"
+	"strings"
+	"time"
+
+	"veyron.io/veyron/veyron/lib/stats"
+)
+
+func init() {
+	now := time.Now()
+	stats.NewInteger("system/start-time-unix").Set(now.Unix())
+	stats.NewString("system/start-time-rfc1123").Set(now.Format(time.RFC1123))
+	stats.NewString("system/cmdline").Set(strings.Join(os.Args, " "))
+	stats.NewInteger("system/num-cpu").Set(int64(runtime.NumCPU()))
+	stats.NewInteger("system/num-goroutine").Set(int64(runtime.NumGoroutine()))
+	stats.NewString("system/version").Set(runtime.Version())
+	if hostname, err := os.Hostname(); err == nil {
+		stats.NewString("system/hostname").Set(hostname)
+	}
+	exportEnv()
+	exportMemStats()
+}
+
+func exportEnv() {
+	kv := make([]stats.KeyValue, len(os.Environ()))
+	for i, v := range os.Environ() {
+		if parts := strings.SplitN(v, "=", 2); len(parts) == 2 {
+			kv[i] = stats.KeyValue{parts[0], parts[1]}
+		}
+	}
+	stats.NewMap("system/environ").Set(kv)
+}
+
+func exportMemStats() {
+	mstats := stats.NewMap("system/memstats")
+
+	// Get field names to export.
+	var memstats runtime.MemStats
+	fieldNames := []string{}
+	v := reflect.ValueOf(memstats)
+	v.FieldByNameFunc(func(name string) bool {
+		switch v.FieldByName(name).Kind() {
+		case reflect.Bool, reflect.Uint32, reflect.Uint64:
+			fieldNames = append(fieldNames, name)
+		}
+		return false
+	})
+	updateStats := func() {
+		var memstats runtime.MemStats
+		runtime.ReadMemStats(&memstats)
+		v := reflect.ValueOf(memstats)
+		kv := make([]stats.KeyValue, len(fieldNames))
+		for i, name := range fieldNames {
+			kv[i] = stats.KeyValue{name, v.FieldByName(name).Interface()}
+		}
+		mstats.Set(kv)
+	}
+	// Update stats now and every 10 seconds afterwards.
+	updateStats()
+	go func() {
+		for {
+			time.Sleep(10 * time.Second)
+			updateStats()
+		}
+	}()
+}
diff --git a/lib/stats/sysstats/sysstats_test.go b/lib/stats/sysstats/sysstats_test.go
new file mode 100644
index 0000000..e341c1e
--- /dev/null
+++ b/lib/stats/sysstats/sysstats_test.go
@@ -0,0 +1,33 @@
+package sysstats_test
+
+import (
+	"os"
+	"testing"
+
+	"veyron.io/veyron/veyron/lib/stats"
+	_ "veyron.io/veyron/veyron/lib/stats/sysstats"
+)
+
+func TestHostname(t *testing.T) {
+	obj, err := stats.GetStatsObject("system/hostname")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	expected, err := os.Hostname()
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if got := obj.Value(); got != expected {
+		t.Errorf("unexpected result. Got %q, want %q", got, expected)
+	}
+}
+
+func TestMemStats(t *testing.T) {
+	alloc, err := stats.GetStatsObject("system/memstats/Alloc")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if v := alloc.Value(); v == uint64(0) {
+		t.Errorf("unexpected Alloc value. Got %v, want != 0", v)
+	}
+}
diff --git a/runtimes/google/rt/rt.go b/runtimes/google/rt/rt.go
index 3692c37..f3f9822 100644
--- a/runtimes/google/rt/rt.go
+++ b/runtimes/google/rt/rt.go
@@ -18,6 +18,7 @@
 	"veyron.io/veyron/veyron2/vlog"
 
 	"veyron.io/veyron/veyron/lib/exec"
+	_ "veyron.io/veyron/veyron/lib/stats/sysstats"
 	"veyron.io/veyron/veyron/profiles"
 	"veyron.io/veyron/veyron/runtimes/google/naming/namespace"
 )