D and Go are both interesting languages with very different philosophies.
Go seems to aim for simple as possible while being fast, flexible, and featureful enough.
D seems to aim for fast, flexible, and featureful as possible while being simple enough.
An illustrative example might be the access of globals in multiple threads.
(In my limited understanding) In D, you can declare your data immutable, which means the compiler can verify that it is safe for concurrent reading. If it isn't immutable, it is by default thread-local, so multiple threads can't access it and there is a bit of overhead associated with writing to it, but it is safe. If you actually want to access a global in multiple threads, there is a "shared" storage class you can assign it, making it explicit that you intend to access it across multiple threads.
By contrast, global variables in Go have no protections. If you want to access them safely across multiple threads, that's your problem. Go provides the easy means to make your code threadsafe, but it doesn't require you to write threadsafe code via static analysis and type qualifiers.
The Go designers seem to believe in "small government" language design; the language isn't responsible for forcing you to write correct code or doing static analysis or supporting unit testing or allowing arbitrary computation at compile time. They're old school Unix guys, where the philosophy is "Write programs that do one thing and do it well. Write programs to work together". Parsing Go is not too difficult, and Go comes with a complete Go parsing library, so writing additional tools isn't terribly difficult.
The D designer(s) seem to be more "big government" in the language design. The language is designed to take care of as much as possible, to be useful for every purpose. It can be safe, it can be unsafe. It can be garbage collected, or you can manage memory manually. It has built-in unit testing, lazy evaluation, static analysis, macros, and anything else you could want. It looks like it does a pretty decent job of doing everything.
Go doesn't yet have generics, so it can be awkward to write your own general purpose data structures.
One big advantage that Go has is that it has Google paying for it, so it has a team working (I assume) full time to improve it's libraries and tools. If Google is using Go internally to any significant extent, then you can be pretty sure that Go will exist and be well-supported for some time.
Both languages have the benefit of skillful and experienced team members, which is a big deal.
Anyway, both are under active development and making rapid advances, so I don't know that I'd use either for a serious project right now, but I'm watching with interest.