Introduction
Usually, programming tutorials and research papers have been a bit difficult to understand.
Not because the code is complicated, but because the attention shifts between the text and its explanation.
When someone presents a technical article, the author knows which line matters at each moment but readers might not.
We use static artefacts, diagrams, images or even screenshots to explain. This includes:
- Blog Posts
- Research & Documentation
- Code Snippets
But programming is not static.
When a function is executed, the data flows and state keeps changing.
So when we explain these ideas, we freeze everything into a screenshot.
Real Problem
Consider a simple explanation in a blog.
We paste a block of code, then the explanation refers to parts of it.
Now the reader has to
- scroll up/down
- remember previous lines
- mentally simulate execution
To avoid this, authors often repeat code blocks, shrink snippets and/or split explanations.
This is hard work for both writers and readers.
Code execution is a
SEQUENCE
Documentation is aSNAPSHOT
This gap is where the friction lives.
Experiment
So I tried a small experiment. What if documentation was a not a page but a timeline?
Instead of describing what the program does, what if we rendered the explanation?
I built a CLI tool that generates a video directly from text script.
- No Screen Recording
- No Video Editor
Just a script
I called it Rustimate - an animation engine written in Rust.
DSL
Here's how the script looks like
scene "example" {
mode: editor
editor: neovim
animation: typewriter
code {
file: "main.rs"
lines: 8..12
highlight: [10]
}
}
Comparison
This is how a traditional explanation looks like:
There is absolutely nothing wrong with this format and this is how all of us learn programming or consume technical content.
But in this format, the reader needs to manually connect explanation and execution.
Here's the same concept rendered as a short guided sequence:
This is not a recording. Rustimate renders the editor itself and guides attention, showing exactly which line matters, and at the moment at which it matters.
The information did not change, only the medium/format did.
The video does not replace the article, it syncs the reader's attention. After watching a guided explanation, the code is no longer unfamiliar.
What Rustimate is (and is not)
Rustimate is not an AI tool.
It does not generate any code
It does not summarize documentation.
It helps guide attention. You describe how understanding should unfold and the engine will turn it into a video.
Who is this for
This could help -
- Educators explaining code and algorithm
- Developers writing tutorials and blogs
- Scientists and Researchers presenting ideas
- Technical YouTube creators
Not to replace writing but to complement it with motion.
Philosophy
Programming sits between logic and explanations. We have powerful languages for building software, but most of our teaching still relies on static pages and screenshots.
Rustimate is my attempt to explore this missing gap - A medium between code and storytelling.
Conclusion
This is still in early stages. I am not presenting it as a finished product but as an idea I am testing.
If it resonates with you then I would genuinely like to hear your thoughts. Thank you!
References
Website: Rustimate
Original Article: Doc2Quarto


Top comments (0)