So, as of this writing, I have read all 5 books available on Amazon on the Vulkan API and I would say that Vulkan Cookbook is one of the better resources out there. The format of the book is similar to other “cookbooks” you may have seen, with each recipe essentially describing one technique in a stand-alone fashion. Meaning the steps for each one will list fundamentals, like creating a logical device and all the other prerequisites, so you can easily refer back to one chapter when it’s time to implement a particular feature. I would personally recommend reading the text from front-to-back, as I think it’s a better way to learn, but you could certainly jump around and still not miss much (assuming you already have some understanding of Vulkan). Author Pawel Lapinski does a great job of showing real code for each recipe and only shows what is actually necessary for a technique. Unlike some other books, this isn’t a dry listing of the API documentation, rather the author shows practical usage of the API with some brief explanation. For this type of text, I think this works great and I imagine it would be very helpful to refer back to when it comes time to implement into your project.

Among the chapters, Lapinski covers: instances and devices, image presentation, command buffers and synchronization, resources and memory, descriptor sets, render passes and framebuffers, shaders, graphics and compute pipelines, command recording and drawing, along with some additional chapters at the end for more general graphics programming concepts like loading textures and 3d models, lighting and shadowing, and cubemapping. Each chapter itself is then broken down into smaller recipes, that could be something like “enumerating available physical devices” to “submitting a command buffer to a queue”. This is really quite a good mix of topics, and, at 700 pages, adequate coverage is given to the most commonly used parts of the Vulkan API. Having already worked through some tutorials online, and read a few other books on Vulkan, most of the topics here were things I had some familiarity toward already, but I still found the reading helpful.

Due to the tactical nature of the text, I would recommend the book for more intermediate to advanced programmers. While the author does a great job of explaining the specific steps needed to do particular actions in Vulkan, it may be helpful to at least understand some of the big picture before diving in here. I might even say this is the best book on the market today for Vulkan, though I’d probably also recommend reading it after one of the others available. It may be helpful to start with a Hello World type app in Vulkan, in which case you could first follow the awesome tutorial over at vulkan-tutorial.com, or get Kenwright’s Vulkan Graphics API: in 20 Minutes, which was a little rough but still a cheap and quick way to obtain an overview of the API. For beginners, or maybe people that want to start at a more basic level, Introduction to Computer Graphics and the Vulkan API (also by Kenwright) may be a more comfortable spot to jump in at. And the other books out there were good in their own right, though some of them didn’t move past simple function/structure documentation.

One thing I really wish is that someone could make a Vulkan book on the level of Frank Luna’s DirectX series. Luna is able to show many practical graphics programming techniques in one book, and in the end you’ll have a handful of pretty sweet demos to showcase. Though Kenwright attempts this, I still haven’t seen this really accomplished yet for Vulkan. While the end chapters of Vulkan Cookbook do dip into this territory with shadow mapping and post processing, it would be nice to see an entire book written like this. However, given that Vulkan is a relatively new API, it’s probably more useful to start with the basics, and hope that competent readers can port techniques from other APIs once they have a feeling for how things work.

Keep in mind, Vulkan is an advanced and complex topic, and a single book won’t teach you everything you need to know. While many of the Vulkan books out today have seemed to release to mixed reviews, I feel that all of them have been helpful. Even reading the same topics explained by different authors can help with knowledge understanding and retention. And there are also some unique things in each book, so I would fully recommend reading them all if you’re really serious about getting into Vulkan. I realize there are some advanced coders that can study the documentation and hit the ground running, but I find the “guided tour” offered from books to be more conducive to learning for me personally. Your opinion my differ, but I’d have to say that you can’t really go wrong with Vulkan Cookbook by Pawel Lapinski. Recommended.

The first 3/4 of the recipes are pretty much 1:1 to a Vulkan API call. The majority of the text is verbiage for the accompanied code; "Create a variable of type T named X", "Call function F and store result in variable X", etc. It might have been useful as a tutorial, except you'll have to jump back and forth quite a bit- which is also painful since it doesn't contain links to its own recipes.

You won't even want to copy/paste lines of code from the Kindle edition because each is accompanied by a monster 209 character attribution.

There are a few helpful diagrams to explain concepts like physical vs. logical devices, different presentation modes, command buffers/queues, etc. But in general, the book could have been written as a tutorial about half the length rather than recipes that aren't actually useful on their own.

As other reviewers have mentioned, save your money and read online tutorials.

The book is well organized and thorough but it largely parallels other Vulkan tutorials I've already gone through. I was hoping for a bit more diversity in the material, like recipes to solve unique kinds of problems.

This book should have came out on par with the API's release date, but that's no fault of the author. I give 4 stars just for the format and actually having source code alone, where another still hasn't posted/gave up posting any for reference. There are typos here and there and source code folders aren't exactly intuitive. But overall, I think this book will allow programmers to FINALLY and really learn how the API works and we should be seeing what people have made across the net in the near future.

There are very few sources for Vulkan even on the internet. This is the best book or any documentation really that you'll find on it. The other books are just basic documentation and grossly complex for the sake of complexity. This book actually takes you step by step with great detail

Great book if you already know Vulkan, maybe. Certainly not something to learn from. Tells you how to do a bunch of different things, but those different things are totally disjoint, and not really all that helpful in building a cohesive program. To that end, I don't know of a book I'd recommend. I know what a "cookbook" usually is and wouldn't have bought this if there wasn't a dearth of other Vulkan books to go around, and this one didn't disappoint as far as cookbooks go; in fact, it's more of a cookbook than other "cookbooks" I've used, like for OpenGL. I basically resorted to learning Vulkan by having Grok create examples for me to cheat-sheet off of, and carefully analyzing what Grok was doing.

very clear (given the subject material, vulkan is stupidly verbose). tons of practical examples.

tl;dr: I really wanted to like this book, but it's just not very good. The only *slightly* useful parts are the last 3 chapters/150 pages where the task is higher-level and then it shows you how to break it down into Vulkan. Stick with the online tutorials and the API reference and save your money.

Longer discussion: I'm really not sure who this book is meant for. Nobody doing Vulkan needs a multi-hundred page summary of the basic API. Even worse, examples are in C++ (this is a sin of practically *every* Vulkan tutorial writer) when Vulkan has probably the single best C API ever devised by mankind (I'm exaggerating--but not by much. How many API's, period, have the hooks to be both forward *and* backward compatible? Yeah, Vulkan does.)

A "cookbook" should have a list of "common higher level tasks", and then break them down into how to do the task. This book, just *barely* starts to do that in the last couple of chapters, but doesn't do it well.

If the author really wanted this book to shine, he should go back through the last 30 years of Siggraph and implement all of the really cool stuff in Vulkan. (This is how you do dynamic shadows. This is how you raycast a scene. This is how you do distance fields. How do you render fonts correctly in 2D. In 3D. These are the dozen uses for a stencil buffer. etc.)

And, even *within* that, he should discuss the "when and why's" of Vulkan. When do you want double vs triple buffering and how do your available submission options reflect that? Why might you want to link the new swapchain to the old swapchain? What tricks should you be using if you're just doing 2D stuff?

And, I'm sorry, but I have *zero* idea where these 5 star ratings are coming from. It probably doesn't merit my one star (it's not actively erroneous as far as I can tell, so it should probably get at least two stars), but there is no possible axis on which this book merits 5 stars.

As someone starting out with Vulkan but a fair amount of graphics development experience, I am finding this book quite hard to get along with.

The book "recipes" are quite isolated and often require objects to be defined which aren't set up until following chapters , so the flow that I would expect is disjointed and frustrating to follow.

What saves it is the source code that comes with it - by combining the two there is a reasonable chance of getting somewhere towards understanding what is going on.

Vulkan is quite a low level API so it is understandable that there is a lot to cover, and as this is a reference book it may prove more useful to come back to once I have a more overall understanding and need to look up detail. But it could do with a more logical structure in my opinion.

Das Buch könnte um die Hälfte dünner sein; endlose Wiederholungen. Es wird keinerlei Überblick vermittelt. Möglicherweise kann ich das Buch später gebrauchen? Als Einstieg absolut ungeeignet.

Die Beispielprogramme haben Bugs, welche erst einmal behoben werden müssen (2 Bugs)!

Un très bon livre sur l'API Vulkan. A noter que le code fourni sur GitHub compile parfaitement avec Visual Studio 2017, c'est agréable.

I would get the Vulkan guide instead. This book is very verbose and the structure is quite messy. This isn't the kind of book that you can follow along to learn Vulkan. It's just a collection of recipes that are not necessarily in the right sequence (sometimes it's using one concept which is explained in a later chapter).

This book could still be useful as a reference manual, but I wouldn't buy the physical book, it's easier to navigate though with the digital edition.