diff --git a/Dockerfile b/Dockerfile
index 603cdaafabed2e33c485a2616b93e5c00b94f2e1..8a538e5781da8326e217210fe8be1009d12c46ac 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,4 +1,4 @@
-# Dockerfile for DGraph
+# Dockerfile for Dgraph
 
 FROM golang:1.6.2
 MAINTAINER Manish Jain <manishrjain@gmail.com>
@@ -18,7 +18,7 @@ RUN mkdir /installs && cd /installs && \
 RUN cd /installs/rocksdb && make shared_lib && make install
 ENV LD_LIBRARY_PATH "/usr/local/lib"
 
-# Install DGraph and update dependencies to right versions.
+# Install Dgraph and update dependencies to right versions.
 RUN go get -v github.com/dgraph-io/dgraph/... && \
     go build -v github.com/dgraph-io/dgraph/... && \
     go test github.com/dgraph-io/dgraph/... && echo "v0.3"
diff --git a/README.md b/README.md
index 366f19db1bb064d6d3825568edd41601734f1575..5a007afc051bafc23afe2b40b02a5f629f379431 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# DGraph
+# Dgraph
 **Scalable, Distributed, Low Latency, High Throughput Graph Database.**
 
 ![logo](https://img.shields.io/badge/status-alpha-red.svg)
@@ -7,9 +7,9 @@
 [![Slack Status](http://slack.dgraph.io/badge.svg)](http://slack.dgraph.io)
 
 
-DGraph's goal is to provide [Google](https://www.google.com) production level scale and throughput,
+Dgraph's goal is to provide [Google](https://www.google.com) production level scale and throughput,
 with low enough latency to be serving real time user queries, over terabytes of structured data.
-DGraph supports [GraphQL](http://graphql.org/) as query language, and responds in [JSON](http://www.json.org/).
+Dgraph supports [GraphQL](http://graphql.org/) as query language, and responds in [JSON](http://www.json.org/).
 
 ---
 
@@ -40,18 +40,18 @@ Please see [Release notes](https://github.com/dgraph-io/dgraph/releases/tag/v0.3
 and [Trello board](https://trello.com/b/PF4nZ1vH) for more information.
 
 `Mar 2016 - Branch v0.2`
-This is the first truly distributed version of DGraph.
+This is the first truly distributed version of Dgraph.
 Please see the [release notes here](https://discuss.dgraph.io/t/dgraph-v0-2-release/17).
 
 `MVP launch - Dec 2015 - Branch v0.1`
-This is a minimum viable product, alpha release of DGraph. **It's not meant for production use.**
+This is a minimum viable product, alpha release of Dgraph. **It's not meant for production use.**
 This version is not distributed and support for GraphQL is partial.
 [See the Roadmap](https://github.com/dgraph-io/dgraph/issues/1) for list of working and planned features.
 
 Your feedback is welcome. Feel free to [file an issue](https://github.com/dgraph-io/dgraph/issues)
-when you encounter bugs and to direct the development of DGraph.
+when you encounter bugs and to direct the development of Dgraph.
 
-There's an instance of DGraph running at http://dgraph.xyz, that you can query without installing DGraph.
+There's an instance of Dgraph running at http://dgraph.xyz, that you can query without installing Dgraph.
 This instance contains 21M facts from [Freebase Film Data](http://www.freebase.com/film).
 See [Queries and Mutations below](#queries-and-mutations) for sample queries.
 `curl dgraph.xyz/query -XPOST -d '{}'`
@@ -60,7 +60,7 @@ See [Queries and Mutations below](#queries-and-mutations) for sample queries.
 ## Quick Testing
 
 ### Single instance via Docker
-There's a docker image that you can readily use for playing with DGraph.
+There's a docker image that you can readily use for playing with Dgraph.
 ```
 $ docker pull dgraph/dgraph:latest
 # Setting a `somedir` volume on the host will persist your data.
@@ -103,7 +103,7 @@ $ tar -xzvf uids.async.tar.gz -C $DIR
 $ tar -xzvf postings.tar.gz -C $DIR
 # You should now see directories p0, p1, p2 and uasync.final. The last directory name is unfortunate, but made sense at the time.
 ```
-For quick testing, you can bring up 3 different processes of DGraph. You can of course, also set this up across multiple servers.
+For quick testing, you can bring up 3 different processes of Dgraph. You can of course, also set this up across multiple servers.
 ```
 go build . && ./dgraph --instanceIdx 0 --mutations $DIR/m0 --port 8080 --postings $DIR/p0 --workers ":12345,:12346,:12347" --uids $DIR/uasync.final --workerport ":12345" &
 go build . && ./dgraph --instanceIdx 1 --mutations $DIR/m1 --port 8082 --postings $DIR/p1 --workers ":12345,:12346,:12347" --workerport ":12346" &
@@ -123,7 +123,7 @@ All the instructions below are based on a Debian/Ubuntu system.
 Download and install [Go 1.6 from here](https://golang.org/dl/).
 
 ### Install RocksDB
-DGraph depends on [RocksDB](https://github.com/facebook/rocksdb) for storing posting lists.
+Dgraph depends on [RocksDB](https://github.com/facebook/rocksdb) for storing posting lists.
 
 ```
 # First install dependencies.
@@ -143,8 +143,8 @@ This would install RocksDB library in `/usr/local/lib`. Make sure that your `LD_
 export LD_LIBRARY_PATH="/usr/local/lib"
 ```
 
-### Install DGraph
-Now get [DGraph](https://github.com/dgraph-io/dgraph) code. DGraph uses `govendor` to fix dependency versions. Version information for these dependencies is included in the `github.com/dgraph-io/dgraph/vendor` directory under the `vendor.json` file.  
+### Install Dgraph
+Now get [Dgraph](https://github.com/dgraph-io/dgraph) code. Dgraph uses `govendor` to fix dependency versions. Version information for these dependencies is included in the `github.com/dgraph-io/dgraph/vendor` directory under the `vendor.json` file.  
 
 ```
 go get -u github.com/kardianos/govendor
@@ -221,7 +221,7 @@ using SSD persistent disk. Instance 2 took a bit longer, and finished in 15 mins
 Note that `stw_ram_mb` is based on the memory usage perceived by Golang. It currently doesn't take into account the memory usage by RocksDB. So, the actual usage is higher.
 
 ### Server
-Now that the data is loaded, you can run the DGraph servers. To serve the 3 shards above, you can follow the [same steps as here](#multiple-distributed-instances).
+Now that the data is loaded, you can run the Dgraph servers. To serve the 3 shards above, you can follow the [same steps as here](#multiple-distributed-instances).
 Now you can run GraphQL queries over freebase film data like so:
 ```
 curl localhost:8080/query -XPOST -d '{
@@ -284,7 +284,7 @@ Consecutive runs of the same query took much lesser time (80 to 100ms), due to p
 
 ## Queries and Mutations
 You can see a list of [sample queries here](https://discuss.dgraph.io/t/list-of-test-queries/22).
-DGraph also supports mutations via GraphQL syntax.
+Dgraph also supports mutations via GraphQL syntax.
 Because GraphQL mutations don't contain complete data, the mutation syntax uses [RDF NQuad format](https://www.w3.org/TR/n-quads/).
 ```
 mutation {
@@ -298,7 +298,7 @@ mutation {
 ```
 
 You can batch multiple NQuads in a single GraphQL query.
-DGraph would assume that any data in `<>` is an external id (XID),
+Dgraph would assume that any data in `<>` is an external id (XID),
 and it would retrieve or assign unique internal ids (UID) automatically for these.
 You can also directly specify the UID like so: `_uid_: 0xhexval` or `_uid_: intval`.
 
@@ -320,7 +320,7 @@ query {
 The query portion is executed after the mutation, so this would return `greg` as one of the results.
 
 
-## Contributing to DGraph
+## Contributing to Dgraph
 - See a list of issues [that we need help with](https://github.com/dgraph-io/dgraph/issues?q=is%3Aissue+is%3Aopen+label%3Ahelp_wanted).
 - Please see [contributing to Dgraph](https://discuss.dgraph.io/t/contributing-to-dgraph/20) for guidelines on contributions.
 - *Alpha Program*: If you want to contribute to Dgraph on a continuous basis and need some Bitcoins to pay for healthy food, talk to us.
@@ -334,5 +334,5 @@ The query portion is executed after the mutation, so this would return `greg` as
 - [Lightening Talk](http://go-talks.appspot.com/github.com/dgraph-io/dgraph/present/sydney5mins/g.slide#1) on 29th Oct, 2015 at Go meetup, Sydney.
 
 ## About
-I, [Manish R Jain](https://twitter.com/manishrjain), the author of DGraph, used to work on Google Knowledge Graph.
+I, [Manish R Jain](https://twitter.com/manishrjain), the author of Dgraph, used to work on Google Knowledge Graph.
 My experience building large scale, distributed (Web Search and) Graph systems at Google is what inspired me to build this.
diff --git a/client/dgraphclient-go/main.go b/client/dgraphclient-go/main.go
index d824a8931f5d109e770b2bb4d7a8f597d11589e2..afebf93a58d253a2e19bc72cd3fd6fcda24f9a34 100644
--- a/client/dgraphclient-go/main.go
+++ b/client/dgraphclient-go/main.go
@@ -40,7 +40,7 @@ func main() {
 	}
 	defer conn.Close()
 
-	c := graph.NewDGraphClient(conn)
+	c := graph.NewDgraphClient(conn)
 
 	resp, err := c.Query(context.Background(), &graph.Request{Query: *q})
 	if err != nil {
diff --git a/cluster/doc.go b/cluster/doc.go
index 10ff0e23106cbc7db6ebe18d83941e8c47fbe9e1..b9c35d48179982dcb3aeaec0a7e50973cc36c43a 100644
--- a/cluster/doc.go
+++ b/cluster/doc.go
@@ -1,5 +1,5 @@
 /*
- * Copyright 201666666 DGraph Labs, Inc.
+ * Copyright 2016 Dgraph Labs, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/cmd/dgraph/main.go b/cmd/dgraph/main.go
index 03a06ffe85066f8e47c18234885b80cd0df24d7b..0cb0a5865773334ae40cc5d847be963ae9fcf66f 100644
--- a/cmd/dgraph/main.go
+++ b/cmd/dgraph/main.go
@@ -214,7 +214,7 @@ func queryHandler(w http.ResponseWriter, r *http.Request) {
 	fmt.Fprint(w, string(js))
 }
 
-// server is used to implement graph.DGraphServer
+// server is used to implement graph.DgraphServer
 type server struct{}
 
 // This method is used to execute the query and return the response to the
@@ -290,7 +290,7 @@ func (s *server) Query(ctx context.Context,
 	return resp, err
 }
 
-// This function register a DGraph grpc server on the address, which is used
+// This function register a Dgraph grpc server on the address, which is used
 // exchanging protocol buffer messages.
 func runGrpcServer(address string) {
 	ln, err := net.Listen("tcp", address)
@@ -301,7 +301,7 @@ func runGrpcServer(address string) {
 	log.Printf("Client worker listening: %v", ln.Addr())
 
 	s := grpc.NewServer()
-	graph.RegisterDGraphServer(s, &server{})
+	graph.RegisterDgraphServer(s, &server{})
 	if err = s.Serve(ln); err != nil {
 		log.Fatalf("While serving gRpc requests", err)
 	}
diff --git a/docs/example.md b/docs/example.md
index e44bfacf820230d920ce5669ae1592fe5e276319..e2b7ef8e83b9a7eaa3346a23bf7fd668677edbc6 100644
--- a/docs/example.md
+++ b/docs/example.md
@@ -1,6 +1,6 @@
 # Dgraph Design Doc
 
-To explain DGraph working, let's start with an example query we should be able
+To explain Dgraph working, let's start with an example query we should be able
 to run.
 
 Query to answer:
diff --git a/docs/mvp.md b/docs/mvp.md
index 2cb8bcc13da645d383afb7f22a2ffd84022d3a29..a7fc9e45185bcce47d0ea4b01cd86a220dbeeddf 100644
--- a/docs/mvp.md
+++ b/docs/mvp.md
@@ -60,7 +60,7 @@ as the mode of communication.
 - Versioning of data wouldn't be provided in this, or later versions. The best way I can
 currently think of to do versioning would involve writing the deltas, and reading them back
 to generate the final state. This would be too slow and memory consuming for generating the
-long posting lists that we'll encounter in DGraph.
+long posting lists that we'll encounter in Dgraph.
 
 ## Terminology
 
diff --git a/present/ann.txt b/present/ann.txt
index a0dea0d52aa2419210d543940994ea09e00e2679..f8fa806cf3975a77aa4392965b57ee98442b8026 100644
--- a/present/ann.txt
+++ b/present/ann.txt
@@ -1,6 +1,6 @@
-This is a post to announce DGraph, an open source, distributed, scalable native graph database. DGraph is designed to handle terabytes of structured data, over commodity hardware.
+This is a post to announce Dgraph, an open source, distributed, scalable native graph database. Dgraph is designed to handle terabytes of structured data, over commodity hardware.
 
-The design and inspiration is drawn from my experiences working in Google Knowledge Infra group. DGraph is under active development, and is looking to hire talented engineers.
+The design and inspiration is drawn from my experiences working in Google Knowledge Infra group. Dgraph is under active development, and is looking to hire talented engineers.
 
 Github page: https://github.com/dgraph-io/dgraph
 
diff --git a/present/sydney5mins/g.slide b/present/sydney5mins/g.slide
index 1e4b1fab167b25002195d3fe09347a4bddea1234..6425334aac62bebdb6b9e1cb91b65b7573ce66b2 100644
--- a/present/sydney5mins/g.slide
+++ b/present/sydney5mins/g.slide
@@ -1,4 +1,4 @@
-DGraph
+Dgraph
 Go Meetup Sydney
 29 Oct 2015
 Tags: go golang dgraph graph
@@ -20,11 +20,11 @@ manishrjain@gmail.com
 
 .image graph.png
 
-* What is DGraph
+* What is Dgraph
 
 [[https://github.com/dgraph-io/dgraph][https://github.com/dgraph-io/dgraph]]
 
-DGraph is an open source, distributed, low-latency graph serving system written in Go.
+Dgraph is an open source, distributed, low-latency graph serving system written in Go.
 
 - *Low*Latency*: Minimize the latency of query execution.
 
diff --git a/query/graph/graphresponse.pb.go b/query/graph/graphresponse.pb.go
index aae952c586e6386ae21edd780510bb849336dae4..1f0a8218d5a3cef214be9af478bb6ca72c3b82ea 100644
--- a/query/graph/graphresponse.pb.go
+++ b/query/graph/graphresponse.pb.go
@@ -132,89 +132,89 @@ var _ grpc.ClientConn
 // is compatible with the grpc package it is being compiled against.
 const _ = grpc.SupportPackageIsVersion2
 
-// Client API for DGraph service
+// Client API for Dgraph service
 
-type DGraphClient interface {
+type DgraphClient interface {
 	Query(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error)
 }
 
-type dGraphClient struct {
+type dgraphClient struct {
 	cc *grpc.ClientConn
 }
 
-func NewDGraphClient(cc *grpc.ClientConn) DGraphClient {
-	return &dGraphClient{cc}
+func NewDgraphClient(cc *grpc.ClientConn) DgraphClient {
+	return &dgraphClient{cc}
 }
 
-func (c *dGraphClient) Query(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
+func (c *dgraphClient) Query(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
 	out := new(Response)
-	err := grpc.Invoke(ctx, "/graph.DGraph/Query", in, out, c.cc, opts...)
+	err := grpc.Invoke(ctx, "/graph.Dgraph/Query", in, out, c.cc, opts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-// Server API for DGraph service
+// Server API for Dgraph service
 
-type DGraphServer interface {
+type DgraphServer interface {
 	Query(context.Context, *Request) (*Response, error)
 }
 
-func RegisterDGraphServer(s *grpc.Server, srv DGraphServer) {
-	s.RegisterService(&_DGraph_serviceDesc, srv)
+func RegisterDgraphServer(s *grpc.Server, srv DgraphServer) {
+	s.RegisterService(&_Dgraph_serviceDesc, srv)
 }
 
-func _DGraph_Query_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+func _Dgraph_Query_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(Request)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(DGraphServer).Query(ctx, in)
+		return srv.(DgraphServer).Query(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/graph.DGraph/Query",
+		FullMethod: "/graph.Dgraph/Query",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(DGraphServer).Query(ctx, req.(*Request))
+		return srv.(DgraphServer).Query(ctx, req.(*Request))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 
-var _DGraph_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "graph.DGraph",
-	HandlerType: (*DGraphServer)(nil),
+var _Dgraph_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "graph.Dgraph",
+	HandlerType: (*DgraphServer)(nil),
 	Methods: []grpc.MethodDesc{
 		{
 			MethodName: "Query",
-			Handler:    _DGraph_Query_Handler,
+			Handler:    _Dgraph_Query_Handler,
 		},
 	},
 	Streams: []grpc.StreamDesc{},
 }
 
 var fileDescriptor0 = []byte{
-	// 310 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x5c, 0x51, 0xcd, 0x4e, 0xf3, 0x30,
-	0x10, 0xfc, 0xdc, 0x26, 0xfd, 0xd9, 0x7e, 0x6a, 0xd1, 0xc2, 0x21, 0x20, 0x04, 0x95, 0x2f, 0x54,
-	0x1c, 0x0a, 0x2a, 0xbc, 0x01, 0x48, 0x5c, 0x10, 0x02, 0xf3, 0x04, 0x69, 0x6b, 0xb5, 0x91, 0x2a,
-	0xc7, 0xd8, 0x0e, 0x22, 0xaf, 0xc3, 0x93, 0x62, 0x6f, 0x9c, 0x52, 0x71, 0x1b, 0xcf, 0x8c, 0x76,
-	0xc6, 0xbb, 0x70, 0xbc, 0x31, 0xb9, 0xde, 0x1a, 0x69, 0x75, 0xa9, 0xac, 0x9c, 0x6b, 0x53, 0xba,
-	0x12, 0x53, 0x22, 0xf9, 0x25, 0xf4, 0x85, 0xfc, 0xa8, 0xa4, 0x75, 0x78, 0x02, 0xa9, 0x07, 0xa6,
-	0xce, 0xd8, 0x94, 0xcd, 0x86, 0xa2, 0x79, 0xf0, 0x77, 0xe8, 0x3f, 0xe7, 0x4e, 0xaa, 0x55, 0x8d,
-	0x19, 0xf4, 0x75, 0x6e, 0x6c, 0xa1, 0x36, 0xd1, 0xd2, 0x3e, 0xf1, 0x02, 0xc0, 0x4f, 0x5d, 0x49,
-	0x4b, 0x62, 0x87, 0xc4, 0x03, 0x06, 0xc7, 0xd0, 0xd1, 0xcb, 0xac, 0x4b, 0xbc, 0x47, 0xfc, 0x16,
-	0x06, 0xaf, 0xa6, 0xd4, 0xd2, 0xb8, 0x1a, 0x11, 0x12, 0xef, 0xd4, 0x71, 0x24, 0x61, 0x3c, 0x82,
-	0xee, 0x67, 0xbe, 0xa3, 0x41, 0xff, 0x45, 0x80, 0xfc, 0x9b, 0x41, 0xf2, 0x52, 0xae, 0x65, 0x90,
-	0xaa, 0x62, 0x4d, 0xee, 0x44, 0x04, 0x18, 0x98, 0x2f, 0xcf, 0x34, 0xa9, 0x01, 0xe2, 0x39, 0x0c,
-	0x73, 0xe7, 0x4c, 0xb1, 0xac, 0x9c, 0x8c, 0xa9, 0xbf, 0x04, 0xde, 0x50, 0xd9, 0x10, 0x5e, 0x48,
-	0x9b, 0x25, 0xd3, 0xee, 0x6c, 0xb4, 0x98, 0xcc, 0x69, 0x1d, 0xf3, 0xb6, 0x95, 0x38, 0xb0, 0xe0,
-	0x15, 0x0c, 0x56, 0xdb, 0x62, 0xb7, 0x36, 0x52, 0x65, 0x29, 0xd9, 0x47, 0xd1, 0x1e, 0x1a, 0x89,
-	0xbd, 0xc8, 0x1f, 0x60, 0x20, 0xe2, 0x96, 0xf1, 0x14, 0x98, 0xa2, 0x96, 0x7f, 0xdc, 0x4c, 0xf9,
-	0x7a, 0xac, 0xf9, 0xdb, 0x68, 0x31, 0x8e, 0x52, 0x5c, 0xb1, 0x60, 0xbb, 0xc5, 0x3d, 0xf4, 0x1e,
-	0x9f, 0x02, 0x89, 0xd7, 0x90, 0xbe, 0x85, 0x1b, 0x60, 0xeb, 0x8a, 0x97, 0x3a, 0x9b, 0xec, 0xdf,
-	0x4d, 0x18, 0xff, 0xb7, 0xec, 0xd1, 0x55, 0xef, 0x7e, 0x02, 0x00, 0x00, 0xff, 0xff, 0x62, 0xcc,
-	0xa3, 0x13, 0xec, 0x01, 0x00, 0x00,
+	// 306 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x5c, 0x51, 0xcb, 0x4e, 0xc3, 0x30,
+	0x10, 0xc4, 0x6d, 0xd2, 0xc7, 0x16, 0xb5, 0x68, 0xe1, 0x10, 0x10, 0x82, 0xca, 0x17, 0x2a, 0x0e,
+	0x05, 0x15, 0xfe, 0x00, 0x8e, 0x08, 0x81, 0xf9, 0x82, 0xb4, 0xb5, 0xda, 0x48, 0x95, 0x63, 0x6c,
+	0x07, 0x91, 0xdf, 0xe1, 0x4b, 0xb1, 0x37, 0x4e, 0xa9, 0xb8, 0x8d, 0x67, 0x46, 0x3b, 0xe3, 0x5d,
+	0x38, 0xdd, 0x98, 0x5c, 0x6f, 0x8d, 0xb4, 0xba, 0x54, 0x56, 0xce, 0xb5, 0x29, 0x5d, 0x89, 0x29,
+	0x91, 0xfc, 0x1a, 0xfa, 0x42, 0x7e, 0x56, 0xd2, 0x3a, 0x3c, 0x83, 0xd4, 0x03, 0x53, 0x67, 0x6c,
+	0xca, 0x66, 0x43, 0xd1, 0x3c, 0xf8, 0x07, 0xf4, 0x5f, 0x72, 0x27, 0xd5, 0xaa, 0xc6, 0x0c, 0xfa,
+	0x3a, 0x37, 0xb6, 0x50, 0x9b, 0x68, 0x69, 0x9f, 0x78, 0x05, 0xe0, 0xa7, 0xae, 0xa4, 0x25, 0xb1,
+	0x43, 0xe2, 0x01, 0x83, 0x63, 0xe8, 0xe8, 0x65, 0xd6, 0x25, 0xde, 0x23, 0x7e, 0x0f, 0x83, 0x37,
+	0x53, 0x6a, 0x69, 0x5c, 0x8d, 0x08, 0x89, 0x77, 0xea, 0x38, 0x92, 0x30, 0x9e, 0x40, 0xf7, 0x2b,
+	0xdf, 0xd1, 0xa0, 0x63, 0x11, 0x20, 0xff, 0x61, 0x90, 0xbc, 0x96, 0x6b, 0x19, 0xa4, 0xaa, 0x58,
+	0x93, 0x3b, 0x11, 0x01, 0x06, 0xe6, 0xdb, 0x33, 0x4d, 0x6a, 0x80, 0x78, 0x09, 0xc3, 0xdc, 0x39,
+	0x53, 0x2c, 0x2b, 0x27, 0x63, 0xea, 0x1f, 0x81, 0x77, 0x54, 0x36, 0x84, 0x17, 0xd2, 0x66, 0xc9,
+	0xb4, 0x3b, 0x1b, 0x2d, 0x26, 0x73, 0x5a, 0xc7, 0xbc, 0x6d, 0x25, 0x0e, 0x2c, 0x78, 0x03, 0x83,
+	0xd5, 0xb6, 0xd8, 0xad, 0x8d, 0x54, 0x59, 0x4a, 0xf6, 0x51, 0xb4, 0x87, 0x46, 0x62, 0x2f, 0xf2,
+	0x27, 0x18, 0x88, 0xb8, 0x65, 0x3c, 0x07, 0xa6, 0xa8, 0xe5, 0x3f, 0x37, 0x53, 0xbe, 0x1e, 0x6b,
+	0xfe, 0x36, 0x5a, 0x8c, 0xa3, 0x14, 0x57, 0x2c, 0xd8, 0x6e, 0xf1, 0x08, 0xbd, 0x67, 0x22, 0xf1,
+	0x16, 0xd2, 0xf7, 0x70, 0x03, 0x6c, 0x5d, 0xf1, 0x52, 0x17, 0x93, 0xfd, 0xbb, 0x09, 0xe3, 0x47,
+	0xcb, 0x1e, 0x5d, 0xf5, 0xe1, 0x37, 0x00, 0x00, 0xff, 0xff, 0x60, 0x8c, 0x1b, 0xb0, 0xec, 0x01,
+	0x00, 0x00,
 }
diff --git a/query/graph/graphresponse.proto b/query/graph/graphresponse.proto
index 225f4ae8934c92db072590ab0dd0104530a489e3..0790939112946f111a532569c0ec54177e6976ec 100644
--- a/query/graph/graphresponse.proto
+++ b/query/graph/graphresponse.proto
@@ -4,7 +4,7 @@
 syntax="proto3";
 package graph;
 
-service DGraph {
+service Dgraph {
   rpc Query (Request) returns (Response) {}
 }
 
diff --git a/store/README.md b/store/README.md
index 713ad29fdf6c8eb457bb234661d5993422bb5e4c..2852b194f861786383f181b9f3fd37e82fee4b18 100644
--- a/store/README.md
+++ b/store/README.md
@@ -75,16 +75,16 @@ ok  	github.com/dgraph-io/dgraph/store	55.029s
 ```
 
 ### Thoughts
-DGraph uses append only commit log to sync new mutations to disk before returning.
+Dgraph uses append only commit log to sync new mutations to disk before returning.
 Every time a posting list gets init, it checks for both the stored posting list and
 the mutations committed after the posting list was written. Hence, our access pattern
 from store is largely read-only, with fewer writes. This is true, irrespective of how
 many writes get commited by the end user.
 
-Hence, BoltDB is a better choice. It performs better for reads/seeks, despite DGraph needing
+Hence, BoltDB is a better choice. It performs better for reads/seeks, despite Dgraph needing
 a value copy. Writes are somewhat slower, but that shouldn't be a problem because of the
 above mentioned reasons.
 
 **Update**: Just realized that BoltDB only allows a SINGLE writer at any point in time.
-This is equivalent to a global mutex lock. That'd essentially kill DGraph's performance. So,
+This is equivalent to a global mutex lock. That'd essentially kill Dgraph's performance. So,
 BoltDB is out!