Hello Rustaceans! Because I don't like that virtually all Rust tutorials in the past require at least knowledge of another programming language, I made this tutorial for absolute beginners. Even though I believe many people here would not like it, I want to explicit say that I used LLM to write this tutorial. That said, it has gone through iterations of manual editing, so please read the content before if you want to criticize it. I'm not that good at Rust either, so there might be typos or errors in it. Feedback is welcome 
The rest I want to say is in the foreword of the tutorial.
Great!
My first guess was "One more of these useless 300 pages Rust for Beginners tutorials" which they sell at Amazon.
But your work has actually 900 pages, which might indicate that it can be useful. My estimation was in the past, that a real complete Rust introduction for people without prior computer science and programming experience would have a volume of approx 1000 pages. (A useful Rust introduction for people familiar with other languages needs typically at least 500 pages, generally even 700 pages like the official tutorial or the book of Jim Blandy. It depends if the book actually covers macros and async. All with significantly less than 500 pages is often useless, as Rust is such a complex language. The exception are books which cover only selected and advanced topics like "Effective Rust".
In my personal view using AI support for book generation is a good choice. Most of us are not native English speakers and so will never be able to produce really high quality texts. Well, a few people managed to do it -- Jim Blandy with "Programming Rust", or David Drysdale with "Effective Rust". I think the book of Jon Gjengset has also a good text quality, but I just read a few pages of it.
For my own "Rust for C-Programmers" I optimized the text in many iterations with AI -- initially with ChatGPT 4.1 and finally with Gemini of Google. The point is, one has to instruct the AI very detailed, and has to do many iterations proofreading the result. I needed typically four to five iterations for each chapter, so the book creation took me approx 800 hours in total. I regard the final text quality as very good, much better than my Nim book I wrote in 2020 without AI support. In the last 18 months AI has made further progress, so the result might be even better now. Unfortunately most of the AI-generated books at Amazon seems to be just pure garbage.
You say that you are not an Rust expert. I think that is OK, if you have read already a few Rust books, work very carefully, and have good general knowledge in computer science and programming.
I really hope that your book is a good one. I will try to read at least a few pages, and tell you my review.
Unfortunately, I have the fear, that even when the book is very good, it will be not easy to find actual readers. My feeling is, that there are not so many people that actually are learning Rust in these days. Many interested in Rust have already learned it, and others regard it as too complicated, and might be afraid of a 900 pages full course. So when your book is really great, we would have to do some active advertisement for it. Buying Google ads, or pushing it to Amazon together with a few dozen 5 star (fake) reviews would be an option for advertisement, but I don't really like that, so I just created a website for my own Rust book. But that seems not to help that much, Google had a hard time locating it at all. Bing was a bit faster.
Thank you very much for your appreciation! I found your Rust book and saw that you also planned to write about macros and async but didn't seem to complete them. I took the hard way to explain async, actually implementing a simple runtime. However, I also wonder if it would be too hard for readers. I'm still not sure if this is the best (or at least a viable) approach yet. As for AI usage, I actually put a lot of consideration into it. Not only that I used AI, I also provide a way for readers to make use of AI to get better experience. Kinda sad that the Rust community seems to be strongly against AI.
Actually I had a tiny bit of hope that a co-auther would do that
Currently I do know not much about macros and async, and I have no use case where I would need that. Async is generally difficult, I used it a bit in Nim, and wrote about it in my old Nim book. I have no real motivation to learn Rust macros and async in detail, just for the two missing chapters of my Rust book. And the book is already quite thick.
Kinda sad that the Rust community seems to be strongly against AI.
They are mostly against AI slop, and that is justified. Personally, I am also against human generated slop, and the Internet is full of it. Bad YouTube videos, trivial tutorials, GitHub and Crates.io as some form of low cost junk folder, and many forums and sites like REDDIT contain also a lot of human generated slop.
Interested to know why you’ve got this feeling? I think people now are perhaps learning it differently, maybe together with the help of an LLM (even if it is more of a passive type of learning). On the other hand, maybe people in general are learning less of everything, and rely too much on LLMs. 
That's why I wrote:
the tutorial itself exists for a reason; otherwise, I wouldn’t have written it.
and
Even if you use AI to help you read, that doesn’t mean you can’t come back to the tutorial itself whenever you need it.
I had a first short look, and my feeling is that parts of the text would need many more iterations.
I am not sure if I am allowed to past an AI link here, but will try for reference:
That text section is:
What Is Compiling?
Before we run the program, let’s cover an important concept.
The .rs files we write contain code meant for humans to read — computers can’t actually understand it. So we need a translation step that turns the code we write into a file the computer can execute directly. This translation step is called compiling.
The tool responsible for this is called a compiler, and Rust’s compiler is the rustc we installed last episode.
The good news is that you don’t need to invoke rustc yourself: the cargo run command we’re about to use will automatically compile and then run your program, all in one step.
That is poor text quality, which I generally refuse to read. I can not imagine that it passes an AI check. Especially for beginners text quality is important -- advanced people can often guess what is meant.
"The .rs files we write contain code meant for humans to read — computers can’t actually understand it." is really ugly and not easy to parse for real beginners.
The next iteration of one of my AI models is already a gigantic improvement, and that without knowing the actual context.
Generally, my personal feeling is, that the start of the book should have more general context, when it is really meant for a true beginner. E.G. a basic comparison of interpreted and compiled languages, what a programming language is at all, why we need a translation so the CPU can execute it, and all that. But well, that is my personal view, I tried to cover that in my old Nim book -- some people found those explanations boring, and recently I took that old book offline.
I started with Rust three years ago, and reading this forum from time to time, I had the feeling that there are many people who already learnt Rust quite well, but only very few still in the process of learning. Actually I am still surprised how few beginner questions we have in this forum. I think the same is true for the Reddit Rust area. For my private contacts, it is similar, I know some people who learned Rust already years ago, but actually no one who is just now learning it. Perhaps people now use other learning resources, like Discord or Telegram? And perhaps AI? But still I wonder why there are so few people in this forum who say "I just started learning Rust, I don't really understand ...". Personally for me the tiny number of readers of my own Rust book is also an indication, but there might be other reasons for this
The way you asked AI was too strongly suggestive. To be more specific, "How would you rewrite that section?" strongly suggests that that section is problematic and requires revision. I changed the question to be neutral and then the AI finds it more than acceptable even though it still thinks it can be improved. It's notable that they give totally different advices than what AI said in your session, which strongly suggests that they are nitpicking.
Replying to the last part of your comment. I believe we have to admit that there's a tradeoff between simplicity (or even naiveness) and technicality. It reminds of 11.5 in my tutorial:
On lookup speed, HashMap is nearly constant regardless of size; BTreeMap gets slightly slower with more data, but it’s still fast.
This is super vague. The fact is that HashMap is amortized O(1) and BTreeMap O(log n). However, I decided to prefer simplicity over technicality, which some people may dislike.
My feeling is, that your chapter one is too dense for a true beginner. Note, that people interested in computer science at all, start often at an age of 12 to 14. Actually there are very few, that study computer science or work as adults in that area, that come not in close contact with programming as a kid. And when those actually start with Rust, they might need a more detailed introduction, teaching basic concepts as well. You have early in the book
What Is a Variable?
A variable gives a value a name, so
That is very dense for a kid aged at 12. I think one would have to discuss the concepts of variables in general a bit more, why do we need them, how do they relate to computer memory and CPU registers, what are mutable and immutable variables, how does the assignment process work?. Is a variable some form of named memory region in the computer, what is a (strongly) typed variable in Rust, how does it differ from languages like Python.
All that is very, very hard to explain to kids -- I know that.
Yes indeed. This is a very simplified explanation, in style similar to the book "Rust in a months of lunches", which was the printed book of the freely available "Easy Rust". Some people agreed with me that such too much simplified explanations can easily make a book useless and are a waste of time for the readers. It is not easy to find the optimal grade of detail, but AI can help us a lot. For my Rust book, GPT 4.1 just removed much of my too verbose or unprecise explanations, or at least pointed my to those parts. And often it was able to rewrite my text into more precise, and at the same time more accurate content. Well, that worked not always that nice. OpenAI had for a period of time a model called O3, which just deleted most of my own text, or text from GPT 4.1. I then finally subscribed to Gemini, which I used for the final iteration.
For the HashMap stuff -- I can remember that I tried to explain the basic principles and inner workings in some detail in my Nim book -- I am still unsure if actually someone read it at all
Yes! I know that well -- ordering the context is one of the most difficult parts when writing a book. When we write a book for experienced people, order does not matter a lot, as people know most of it already. For beginners order is very important. We may loose the readers easily, so we have to be very careful to introduce all step by step. All should built up on already known stuff, and all have to be explained in the optimal grade of detail. Not too much, not too few.
The beginning is the most difficult, as some concepts are related in a recursive manner.
Sometimes people complain and stop reading when there is only one concept they can not fully understand immediately. And on the other hand, there are impatient kids, who want to be able to create a video game after reading the first three pages of the book.
That is why it is so hard to create a beginner book in general, and even harder for Rust.
Yesterday evening, I had a look at a few more sections of your book. And I have to admit that I have still a hard time to really see its purpose.
It seems not really be targeting to absolute beginners in Rust -- you are not really explaining stuff better or in more detail than the official tutorials. And the book seems to be not addressed to people really interested in learning the language to understand it to a point beeing able to write code on there own. All the textual explanations are more like fragments -- you shortly explain single points, but it is hard to get a real feeling for the language from your book. For some sections you just miss the point. E.g. for shadowing: Shadowing is a concept present in many languages: A new scope (or function) opens a new name space, where existing symbol names can be temporary redefined. The special point for Rust is, that shadowing inside a scope is allowed as well. In your book you explain it in the opposite order -- the explanation is OK, but the reversed order might be not so good. For generics, you explain how they can be used, and the benefits, but ignore the important point for beginners: How do generics work, when the language is called strongly statically typed. Keyword Monomorphization.
In the first section of your book you give some hints for its purpose: Use by people that let their code mostly be generated by AI, to be able to understand some of the basic structure and constructs. Well, for that case your book might be helpful.
However, I think that your book is absolutely not appropriate for beginners in programming who really wants to learn programming. For those the official tutorials or books like "Programming Rust" by Jim Blandy are a much better choice. Reading your book is a bit like reading a dictionary. And the language is often like from a 14 years old kid in school creating an report for their teacher. THis style seems to be popular now, but I wonder if it really helps understanding.
Well, the book is a large effort. I assume that your native language is Chinese, so it must have been a large amount of work to create such a long English text. I wonder that you said that AI helped generating it. While reading my feeling is more that it is written by a human with very basic english writing skills -- similar to my own writing style.
As for shadowing, I'm not quite sure what you mean. I guess you mean "shadowing at the same level of scope" vs "shadowing in the inner scope." I think that which order is better is debatable, though. As for generics, actually it follows my logic and is quite consistent: when a beginner sees generics, they have absolutely no idea how it can be implemented the other way, until they learn the alternative, which is dynamic dispatch. So monomorphization is introduced very late: in 10.1, when dynamic dispatch is introduced. I also admit the explanation is very short there and it's also debatable if longer explanation is better. However, introducing the idea of monomorphization late is also quite intentional.
I was curious about this - Exercism has a rust track and they publish the number of enrolled students. Archive.org has snapshots of that page:
2021-09-22 38539
2022-01-18 46066
2022-06-18 54800
2023-02-06 71569
2023-07-12 81805
2024-01-27 92935
2024-07-10 103630
2025-02-05 114361
2025-08-04 122601
2026-02-06 130134
2026-08-06 138768
So last two years have been a little weaker - still growing though.
I start to realize maybe the tutorial ideal to me is quite different from to many other people. I like to write bite-sized lessons and avoid introducing the whole picture until it is finally needed. What I tend to think is that there are already enough material if you're sure you want to get a CS degree. Those people probably already knew another programming language and "the book" suffices. In contrast, these short "episodes" are like short videos that tempt people into programming. An immediate question would be: are the several later chapters actually useful? Honestly I'm not quite sure, but I still (almost?) finished the main chapters.
Maybe my style is just a reflection of my imagination to Gen Z 
There actually is a Gen Z I know reading my tutorial, and I believe at least they didn't find it too boring 
Very Cool!